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 types

    33

import time

    34

from time import time as gettime

    35

from threading import Lock, Timer, currentThread

    36

    37

import cPickle

    38

import wx.lib.buttons

    39

import wx.lib.statbmp

    40

import wx.stc

    41

    42

    43

import version

    44

from editors.EditorPanel import EditorPanel

    45

from editors.Viewer import Viewer

    46

from editors.TextViewer import TextViewer

    47

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    48

from editors.DataTypeEditor import DataTypeEditor

    49

from util import paths as paths

    50

from util.MiniTextControler import MiniTextControler

    51

from util.ProcessLogger import ProcessLogger

    52

from util.BitmapLibrary import GetBitmap

    53

from controls.LogViewer import LogViewer

    54

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

    55

from controls import EnhancedStatusBar as esb

    56

from dialogs.AboutDialog import ShowAboutDialog

    57

    58

from PLCControler import \

    59

    LOCATION_CONFNODE, \

    60

    LOCATION_MODULE, \

    61

    LOCATION_GROUP, \

    62

    LOCATION_VAR_INPUT, \

    63

    LOCATION_VAR_OUTPUT, \

    64

    LOCATION_VAR_MEMORY, \

    65

    ITEM_PROJECT, \

    66

    ITEM_RESOURCE

    67

    68

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL, ITEM_CONFNODE

    69

    70

from IDEFrame import \

    71

    TITLE,\

    72

    EDITORTOOLBAR,\

    73

    FILEMENU,\

    74

    EDITMENU,\

    75

    DISPLAYMENU,\

    76

    PROJECTTREE,\

    77

    POUINSTANCEVARIABLESPANEL,\

    78

    LIBRARYTREE,\

    79

    PAGETITLES,\

    80

    IDEFrame, \

    81

    AppendMenu,\

    82

    EncodeFileSystemPath, \

    83

    DecodeFileSystemPath

    84

    85

    86

beremiz_dir = paths.AbsDir(__file__)

    87

    88

    89

def Bpath(*args):

    90

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

    91

    92

    93

MAX_RECENT_PROJECTS = 9

    94

    95

    96

if wx.Platform == '__WXMSW__':

    97

    faces = {

    98

        'mono': 'Courier New',

    99

        'size': 8,

   100

    }

   101

else:

   102

    faces = {

   103

        'mono': 'Courier',

   104

        'size': 10,

   105

    }

   106

   107

   108

MainThread = currentThread().ident

   109

REFRESH_PERIOD = 0.1

   110

   111

   112

class LogPseudoFile(object):

   113

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

   114

    def __init__(self, output, risecall):

   115

        self.red_white = 1

   116

        self.red_yellow = 2

   117

        self.black_white = wx.stc.STC_STYLE_DEFAULT

   118

        self.output = output

   119

        self.risecall = risecall

   120

        # to prevent rapid fire on rising log panel

   121

        self.rising_timer = 0

   122

        self.lock = Lock()

   123

        self.YieldLock = Lock()

   124

        self.RefreshLock = Lock()

   125

        self.TimerAccessLock = Lock()

   126

        self.stack = []

   127

        self.LastRefreshTime = gettime()

   128

        self.LastRefreshTimer = None

   129

   130

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

   131

        if self.lock.acquire():

   132

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

   133

            self.lock.release()

   134

            current_time = gettime()

   135

            self.TimerAccessLock.acquire()

   136

            if self.LastRefreshTimer:

   137

                self.LastRefreshTimer.cancel()

   138

                self.LastRefreshTimer = None

   139

            self.TimerAccessLock.release()

   140

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

   141

                self._should_write()

   142

            else:

   143

                self.TimerAccessLock.acquire()

   144

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

   145

                self.LastRefreshTimer.start()

   146

                self.TimerAccessLock.release()

   147

   148

    def _timer_expired(self):

   149

        if self.RefreshLock.acquire(False):

   150

            self._should_write()

   151

        else:

   152

            self.TimerAccessLock.acquire()

   153

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

   154

            self.LastRefreshTimer.start()

   155

            self.TimerAccessLock.release()

   156

   157

    def _should_write(self):

   158

        app = wx.GetApp()

   159

        if app is not None:

   160

            wx.CallAfter(self._write)

   161

   162

        if MainThread == currentThread().ident:

   163

            if app is not None:

   164

                if self.YieldLock.acquire(0):

   165

                    app.Yield()

   166

                    self.YieldLock.release()

   167

   168

    def _write(self):

   169

        if self.output:

   170

            self.output.Freeze()

   171

            self.lock.acquire()

   172

            for s, style in self.stack:

   173

                if style is None:

   174

                    style = self.black_white

   175

                if style != self.black_white:

   176

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

   177

   178

                # Temporary deactivate read only mode on StyledTextCtrl for

   179

                # adding text. It seems that text modifications, even

   180

                # programmatically, are disabled in StyledTextCtrl when read

   181

                # only is active

   182

                start_pos = self.output.GetLength()

   183

                self.output.SetReadOnly(False)

   184

                self.output.AppendText(s)

   185

                self.output.SetReadOnly(True)

   186

                text_len = self.output.GetLength() - start_pos

   187

   188

                if style != self.black_white:

   189

                    self.output.SetStyling(text_len, style)

   190

            self.stack = []

   191

            self.lock.release()

   192

            self.output.Thaw()

   193

            self.LastRefreshTime = gettime()

   194

            try:

   195

                self.RefreshLock.release()

   196

            except Exception:

   197

                pass

   198

            newtime = time.time()

   199

            if newtime - self.rising_timer > 1:

   200

                self.risecall(self.output)

   201

            self.rising_timer = newtime

   202

   203

    def write_warning(self, s):

   204

        self.write(s, self.red_white)

   205

   206

    def write_error(self, s):

   207

        self.write(s, self.red_yellow)

   208

   209

    def writeyield(self, s):

   210

        self.write(s)

   211

        wx.GetApp().Yield()

   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

   225

ID_FILEMENURECENTPROJECTS = wx.NewId()

   226

   227

   228

class Beremiz(IDEFrame):

   229

   230

    def _init_utils(self):

   231

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

   232

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

   233

   234

        IDEFrame._init_utils(self)

   235

   236

    def _init_coll_FileMenu_Items(self, parent):

   237

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

   238

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

   239

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

   240

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

   241

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

   242

        parent.AppendSeparator()

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

        parent.AppendSeparator()

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

        parent.AppendSeparator()

   259

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

   260

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

   261

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

   273

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

   274

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

   275

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

   276

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

   277

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

   278

   279

    def _RecursiveAddMenuItems(self, menu, items):

   280

        for name, text, help, children in items:

   281

            new_id = wx.NewId()

   282

            if len(children) > 0:

   283

                new_menu = wx.Menu(title='')

   284

                menu.AppendMenu(new_id, text, new_menu)

   285

                self._RecursiveAddMenuItems(new_menu, children)

   286

            else:

   287

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

   288

                           kind=wx.ITEM_NORMAL, text=text)

   289

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

   290

                          id=new_id)

   291

   292

    def _init_coll_AddMenu_Items(self, parent):

   293

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   294

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   295

   296

    def _init_coll_HelpMenu_Items(self, parent):

   297

        def handler(event):

   298

            return wx.MessageBox(

   299

                version.GetCommunityHelpMsg(),

   300

                _(u'Community support'),

   301

                wx.OK | wx.ICON_INFORMATION)

   302

   303

        id = wx.NewId()

   304

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

   305

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

   306

   307

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

   308

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

   309

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

   310

   311

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   312

        parent.SetFieldsCount(3)

   313

   314

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

   315

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

   316

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

   317

   318

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

   319

   320

    def _init_ctrls(self, prnt):

   321

        IDEFrame._init_ctrls(self, prnt)

   322

   323

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   324

   325

        inspectorID = wx.NewId()

   326

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

   327

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

   328

   329

        keyID = wx.NewId()

   330

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

   331

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

   332

   333

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

   334

                                 ("Run",      wx.WXK_F5),

   335

                                 ("Transfer", wx.WXK_F6),

   336

                                 ("Connect",  wx.WXK_F7),

   337

                                 ("Build",    wx.WXK_F11)]:

   338

            def OnMethodGen(obj, meth):

   339

                def OnMethod(evt):

   340

                    if obj.CTR is not None:

   341

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

   342

                    wx.CallAfter(self.RefreshStatusToolBar)

   343

                return OnMethod

   344

            newid = wx.NewId()

   345

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

   346

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

   347

   348

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   349

   350

        self.LogConsole = CustomStyledTextCtrl(

   351

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

   352

                  size=wx.Size(0, 0))

   353

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

   354

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

   355

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

   356

        self.LogConsole.SetReadOnly(True)

   357

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

   358

   359

        # Define Log Console styles

   360

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

   361

        self.LogConsole.StyleClearAll()

   362

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

   363

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

   364

   365

        # Define Log Console markers

   366

        self.LogConsole.SetMarginSensitive(1, True)

   367

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

   368

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

   369

   370

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

   371

   372

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

   373

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

   374

   375

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

   376

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

   377

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

   378

   379

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

   380

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

   381

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

   382

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

   383

   384

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

   385

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

   386

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

   387

        StatusToolBar.Realize()

   388

        self.Panes["StatusToolBar"] = StatusToolBar

   389

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

   390

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

   391

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

   392

                                LeftDockable(False).RightDockable(False))

   393

   394

        self.AUIManager.Update()

   395

   396

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

   397

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   398

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

   399

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

   400

        self.ProgressStatusBar.Hide()

   401

        self.SetStatusBar(self.ConnectionStatusBar)

   402

   403

    def __init_execute_path(self):

   404

        if os.name == 'nt':

   405

            # on windows, desktop shortcut launches Beremiz.py

   406

            # with working dir set to mingw/bin.

   407

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

   408

            # commands invoked by build process by default are

   409

            # found here.

   410

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

   411

   412

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

   413

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

   414

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

   415

        self.__init_execute_path()

   416

   417

        IDEFrame.__init__(self, parent, debug)

   418

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

   419

   420

        self.local_runtime = None

   421

        self.runtime_port = None

   422

        self.local_runtime_tmpdir = None

   423

   424

        self.LastPanelSelected = None

   425

   426

        # Define Tree item icon list

   427

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

   428

        self.LocationImageDict = {}

   429

   430

        # Icons for location items

   431

        for imgname, itemtype in [

   432

                ("CONFIGURATION", LOCATION_CONFNODE),

   433

                ("RESOURCE",      LOCATION_MODULE),

   434

                ("PROGRAM",       LOCATION_GROUP),

   435

                ("VAR_INPUT",     LOCATION_VAR_INPUT),

   436

                ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   437

                ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   438

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

   439

   440

        # Icons for other items

   441

        for imgname, itemtype in [

   442

                ("Extension", ITEM_CONFNODE)]:

   443

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

   444

   445

        if projectOpen is not None:

   446

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   447

   448

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

   449

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

   450

            self.Controler = self.CTR

   451

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

   452

            if not result:

   453

                self.LibraryPanel.SetController(self.Controler)

   454

                self.ProjectTree.Enable(True)

   455

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   456

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

   457

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   458

            else:

   459

                self.ResetView()

   460

                self.ShowErrorMessage(result)

   461

        else:

   462

            self.CTR = ctr

   463

            self.Controler = ctr

   464

            if ctr is not None:

   465

                self.LibraryPanel.SetController(self.Controler)

   466

                self.ProjectTree.Enable(True)

   467

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   468

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   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

   512

            self.local_runtime.kill(gently=False)

   513

            # clear temp dir