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': 'FreeMono',

   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.StackLock = 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

        self.refreshPending = False

   133

   134

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

   135

        self.StackLock.acquire()

   136

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

   137

        self.StackLock.release()

   138

        current_time = gettime()

   139

        with self.TimerAccessLock:

   140

            if self.LastRefreshTimer is not None:

   141

                self.LastRefreshTimer.cancel()

   142

                self.LastRefreshTimer = None

   143

        elapsed = current_time - self.LastRefreshTime

   144

        if elapsed > REFRESH_PERIOD:

   145

            self._should_write()

   146

        else:

   147

            with self.TimerAccessLock:

   148

                if self.LastRefreshTimer is None:

   149

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

   150

                    self.LastRefreshTimer.start()

   151

   152

    def _timer_expired(self):

   153

        self._should_write()

   154

        with self.TimerAccessLock:

   155

            self.LastRefreshTimer = None

   156

   157

    def _should_write(self):

   158

        if MainThread == currentThread().ident:

   159

            app = wx.GetApp()

   160

            if app is not None:

   161

                self._write()

   162

                if self.YieldLock.acquire(0):

   163

                    app.Yield()

   164

                    self.YieldLock.release()

   165

        else:

   166

            with self.RefreshLock:

   167

                if not self.refreshPending:

   168

                    self.refreshPending = True

   169

                    wx.CallAfter(self._write)

   170

   171

    def _write(self):

   172

        if self.output:

   173

            with self.RefreshLock:

   174

                self.output.Freeze()

   175

                self.output.AnnotationClearAll()

   176

                self.StackLock.acquire()

   177

                for s, style in self.stack:

   178

                    if style is None:

   179

                        style = self.black_white

   180

                    if style != self.black_white:

   181

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

   182

   183

                    # Temporary deactivate read only mode on StyledTextCtrl for

   184

                    # adding text. It seems that text modifications, even

   185

                    # programmatically, are disabled in StyledTextCtrl when read

   186

                    # only is active

   187

                    start_pos = self.output.GetLength()

   188

                    self.output.SetReadOnly(False)

   189

                    self.output.AppendText(s)

   190

                    self.output.SetReadOnly(True)

   191

                    text_len = self.output.GetLength() - start_pos

   192

   193

                    if style != self.black_white:

   194

                        self.output.SetStyling(text_len, style)

   195

                self.stack = []

   196

                self.StackLock.release()

   197

                self.output.ScrollToEnd()

   198

                self.output.Thaw()

   199

                self.LastRefreshTime = gettime()

   200

                newtime = time.time()

   201

                if newtime - self.rising_timer > 1:

   202

                    self.risecall(self.output)

   203

                self.rising_timer = newtime

   204

                self.refreshPending = False

   205

   206

   207

    def write_warning(self, s):

   208

        self.write(s, self.red_white)

   209

   210

    def write_error(self, s):

   211

        self.write(s, self.red_yellow)

   212

   213

    def flush(self):

   214

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   215

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

   216

        # disabled in StyledTextCtrl when read only is active

   217

        self.output.SetReadOnly(False)

   218

        self.output.SetText("")

   219

        self.output.SetReadOnly(True)

   220

   221

    def isatty(self):

   222

        return False

   223

   224

    def progress(self, text):

   225

        l = self.output.GetLineCount()-2

   226

        self.output.AnnotationSetText(l, text)

   227

        self.output.AnnotationSetVisible(wx.stc.STC_ANNOTATION_BOXED)

   228

        self.output.AnnotationSetStyle(l, self.black_white)

   229

        if self.YieldLock.acquire(0):

   230

            app = wx.GetApp()

   231

            app.Yield()

   232

            self.YieldLock.release()

   233

   234

   235

ID_FILEMENURECENTPROJECTS = wx.NewId()

   236

   237

   238

class Beremiz(IDEFrame):

   239

   240

    def _init_utils(self):

   241

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

   242

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

   243

   244

        IDEFrame._init_utils(self)

   245

   246

    def _init_coll_FileMenu_Items(self, parent):

   247

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

   248

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

   249

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

   250

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

   251

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

   252

        parent.AppendSeparator()

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

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

   260

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

   261

        parent.AppendSeparator()

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

        parent.AppendSeparator()

   269

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

   270

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

   271

   272

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

   273

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

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

   280

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

   281

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

   282

   283

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

   284

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

   285

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

   286

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

   287

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

   288

   289

    def _RecursiveAddMenuItems(self, menu, items):

   290

        for name, text, helpstr, children in items:

   291

            if len(children) > 0:

   292

                new_menu = wx.Menu(title='')

   293

                menu.AppendMenu(wx.ID_ANY, text, new_menu)

   294

                self._RecursiveAddMenuItems(new_menu, children)

   295

            else:

   296

                item = menu.Append(wx.ID_ANY, text, helpstr)

   297

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

   298

   299

    def _init_coll_AddMenu_Items(self, parent):

   300

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   301

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   302

   303

    def _init_coll_HelpMenu_Items(self, parent):

   304

        def handler(event):

   305

            return wx.MessageBox(

   306

                version.GetCommunityHelpMsg(),

   307

                _(u'Community support'),

   308

                wx.OK | wx.ICON_INFORMATION)

   309

   310

        item = parent.Append(wx.ID_ANY, _(u'Community support'), '')

   311

        self.Bind(wx.EVT_MENU, handler, item)

   312

   313

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

   314

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

   315

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

   316

   317

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   318

        parent.SetFieldsCount(3)

   319

   320

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

   321

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

   322

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

   323

   324

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

   325

   326

    def _init_ctrls(self, prnt):

   327

        IDEFrame._init_ctrls(self, prnt)

   328

   329

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   330

   331

        inspectorID = wx.NewId()

   332

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

   333

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

   334

   335

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

   336

                                 ("Run",      wx.WXK_F5),

   337

                                 ("Transfer", wx.WXK_F6),

   338

                                 ("Connect",  wx.WXK_F7),

   339

                                 ("Build",    wx.WXK_F11)]:

   340

            def OnMethodGen(obj, meth):

   341

                def OnMethod(evt):

   342

                    if obj.CTR is not None:

   343

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

   344

                    wx.CallAfter(self.RefreshStatusToolBar)

   345

                return OnMethod

   346

            newid = wx.NewId()

   347

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

   348

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

   349

   350

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   351

   352

        self.LogConsole = CustomStyledTextCtrl(

   353

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

   354

            size=wx.Size(0, 0))

   355

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

   356

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

   357

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

   358

        self.LogConsole.SetReadOnly(True)

   359

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

   360

   361

        # Define Log Console styles

   362

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

   363

        self.LogConsole.StyleClearAll()

   364

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

   365

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

   366

   367

        # Define Log Console markers

   368

        self.LogConsole.SetMarginSensitive(1, True)

   369

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

   370

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

   371

   372

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

   373

   374

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

   375

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

   376

   377

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

   378

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

   379

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

   380

   381

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

   382

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

   383

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

   384

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

   385

   386

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

   387

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

   388

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

   389

        StatusToolBar.Realize()

   390

        self.Panes["StatusToolBar"] = StatusToolBar

   391

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

   392

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

   393

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

   394

                                LeftDockable(False).RightDockable(False))

   395

   396

        self.AUIManager.Update()

   397

   398

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

   399

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   400

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

   401

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

   402

        self.ProgressStatusBar.Hide()

   403

        self.SetStatusBar(self.ConnectionStatusBar)

   404

   405

    def __init_execute_path(self):

   406

        if os.name == 'nt':

   407

            # on windows, desktop shortcut launches Beremiz.py

   408

            # with working dir set to mingw/bin.

   409

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

   410

            # commands invoked by build process by default are

   411

            # found here.

   412

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

   413

   414

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

   415

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

   416

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

   417

        self.__init_execute_path()

   418

   419

        IDEFrame.__init__(self, parent, debug)

   420

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

   421

   422

        self.local_runtime = None

   423

        self.runtime_port = None

   424

        self.local_runtime_tmpdir = None

   425

   426

        self.LastPanelSelected = None

   427

   428

        # Define Tree item icon list

   429

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

   430

        self.LocationImageDict = {}

   431

   432

        # Icons for location items

   433

        for imgname, itemtype in [

   434

                ("CONFIGURATION", LOCATION_CONFNODE),

   435

                ("RESOURCE",      LOCATION_MODULE),

   436

                ("PROGRAM",       LOCATION_GROUP),

   437

                ("VAR_INPUT",     LOCATION_VAR_INPUT),

   438

                ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   439

                ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   440

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

   441

   442

        # Icons for other items

   443

        for imgname, itemtype in [

   444

                ("Extension", ITEM_CONFNODE)]:

   445

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

   446

   447

        if projectOpen is not None:

   448

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   449

   450

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

   451

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

   452

            self.Controler = self.CTR

   453

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

   454

            if not result:

   455

                self.LibraryPanel.SetController(self.Controler)

   456

                self.ProjectTree.Enable(True)

   457

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   458

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

   459

                self.RefreshAfterLoad()

   460

            else:

   461

                self.ResetView()

   462

                self.ShowErrorMessage(result)

   463

        else:

   464

            self.CTR = ctr

   465

            self.Controler = ctr

   466

            if ctr is not None:

   467

                ctr.SetAppFrame(self, self.Log)

   468

                self.LibraryPanel.SetController(self.Controler)

   469

                self.ProjectTree.Enable(True)

   470

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   471

                self.RefreshAfterLoad()

   472

        if self.EnableDebug:

   473

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   474

   475

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

   476

   477

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

   478

        self.RefreshAll()

   479

        self.LogConsole.SetFocus()

   480

   481

    def RefreshTitle(self):

   482

        name = _("Beremiz")

   483

        if self.CTR is not None:

   484

            projectname = self.CTR.GetProjectName()

   485

            if self.CTR.ProjectTestModified():

   486

                projectname = "~%s~" % projectname

   487

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

   488

        else:

   489

            self.SetTitle(name)

   490

   491

    def StartLocalRuntime(self, taskbaricon=True):

   492

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

   493

            # create temporary directory for runtime working directory

   494

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   495

            # choose an arbitrary random port for runtime

   496

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

   497

            # launch local runtime

   498

            self.local_runtime = ProcessLogger(

   499

                self.Log,

   500

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

   501

                    sys.executable,

   502

                    Bpath("Beremiz_service.py"),

   503

                    self.runtime_port,

   504

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

   505

                    self.local_runtime_tmpdir),

   506

                no_gui=False,