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 PLCControler import \

    60

    LOCATION_CONFNODE, \

    61

    LOCATION_MODULE, \

    62

    LOCATION_GROUP, \

    63

    LOCATION_VAR_INPUT, \

    64

    LOCATION_VAR_OUTPUT, \

    65

    LOCATION_VAR_MEMORY, \

    66

    ITEM_PROJECT, \

    67

    ITEM_RESOURCE

    68

    69

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL, ITEM_CONFNODE

    70

    71

from IDEFrame import \

    72

    TITLE,\

    73

    EDITORTOOLBAR,\

    74

    FILEMENU,\

    75

    EDITMENU,\

    76

    DISPLAYMENU,\

    77

    PROJECTTREE,\

    78

    POUINSTANCEVARIABLESPANEL,\

    79

    LIBRARYTREE,\

    80

    PAGETITLES,\

    81

    IDEFrame, \

    82

    AppendMenu,\

    83

    EncodeFileSystemPath, \

    84

    DecodeFileSystemPath

    85

    86

    87

beremiz_dir = paths.AbsDir(__file__)

    88

    89

    90

def Bpath(*args):

    91

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

    92

    93

    94

MAX_RECENT_PROJECTS = 9

    95

    96

    97

if wx.Platform == '__WXMSW__':

    98

    faces = {

    99

        'mono': 'Courier New',

   100

        'size': 8,

   101

    }

   102

else:

   103

    faces = {

   104

        'mono': 'Courier',

   105

        'size': 10,

   106

    }

   107

   108

   109

MainThread = currentThread().ident

   110

REFRESH_PERIOD = 0.1

   111

   112

   113

class LogPseudoFile(object):

   114

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

   115

    def __init__(self, output, risecall):

   116

        self.red_white = 1

   117

        self.red_yellow = 2

   118

        self.black_white = wx.stc.STC_STYLE_DEFAULT

   119

        self.output = output

   120

        self.risecall = risecall

   121

        # to prevent rapid fire on rising log panel

   122

        self.rising_timer = 0

   123

        self.lock = Lock()

   124

        self.YieldLock = Lock()

   125

        self.RefreshLock = Lock()

   126

        self.TimerAccessLock = Lock()

   127

        self.stack = []

   128

        self.LastRefreshTime = gettime()

   129

        self.LastRefreshTimer = None

   130

   131

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

   132

        if self.lock.acquire():

   133

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

   134

            self.lock.release()

   135

            current_time = gettime()

   136

            self.TimerAccessLock.acquire()

   137

            if self.LastRefreshTimer:

   138

                self.LastRefreshTimer.cancel()

   139

                self.LastRefreshTimer = None

   140

            self.TimerAccessLock.release()

   141

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

   142

                self._should_write()

   143

            else:

   144

                self.TimerAccessLock.acquire()

   145

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

   146

                self.LastRefreshTimer.start()

   147

                self.TimerAccessLock.release()

   148

   149

    def _timer_expired(self):

   150

        if self.RefreshLock.acquire(False):

   151

            self._should_write()

   152

        else:

   153

            self.TimerAccessLock.acquire()

   154

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

   155

            self.LastRefreshTimer.start()

   156

            self.TimerAccessLock.release()

   157

   158

    def _should_write(self):

   159

        app = wx.GetApp()

   160

        if app is not None:

   161

            wx.CallAfter(self._write)

   162

   163

        if MainThread == currentThread().ident:

   164

            if app is not None:

   165

                if self.YieldLock.acquire(0):

   166

                    app.Yield()

   167

                    self.YieldLock.release()

   168

   169

    def _write(self):

   170

        if self.output:

   171

            self.output.Freeze()

   172

            self.lock.acquire()

   173

            for s, style in self.stack:

   174

                if style is None:

   175

                    style = self.black_white

   176

                if style != self.black_white:

   177

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

   178

   179

                # Temporary deactivate read only mode on StyledTextCtrl for

   180

                # adding text. It seems that text modifications, even

   181

                # programmatically, are disabled in StyledTextCtrl when read

   182

                # only is active

   183

                start_pos = self.output.GetLength()

   184

                self.output.SetReadOnly(False)

   185

                self.output.AppendText(s)

   186

                self.output.SetReadOnly(True)

   187

                text_len = self.output.GetLength() - start_pos

   188

   189

                if style != self.black_white:

   190

                    self.output.SetStyling(text_len, style)

   191

            self.stack = []

   192

            self.lock.release()

   193

            self.output.Thaw()

   194

            self.LastRefreshTime = gettime()

   195

            try:

   196

                self.RefreshLock.release()

   197

            except Exception:

   198

                pass

   199

            newtime = time.time()

   200

            if newtime - self.rising_timer > 1:

   201

                self.risecall(self.output)

   202

            self.rising_timer = newtime

   203

   204

    def write_warning(self, s):

   205

        self.write(s, self.red_white)

   206

   207

    def write_error(self, s):

   208

        self.write(s, self.red_yellow)

   209

   210

    def writeyield(self, s):

   211

        self.write(s)

   212

        wx.GetApp().Yield()

   213

   214

    def flush(self):

   215

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   216

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

   217

        # disabled in StyledTextCtrl when read only is active

   218

        self.output.SetReadOnly(False)

   219

        self.output.SetText("")

   220

        self.output.SetReadOnly(True)

   221

   222

    def isatty(self):

   223

        return False

   224

   225

   226

ID_FILEMENURECENTPROJECTS = wx.NewId()

   227

   228

   229

class Beremiz(IDEFrame):

   230

   231

    def _init_utils(self):

   232

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

   233

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

   234

   235

        IDEFrame._init_utils(self)

   236

   237

    def _init_coll_FileMenu_Items(self, parent):

   238

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

   239

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

   240

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

   241

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

   242

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

   243

        parent.AppendSeparator()

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

        parent.AppendSeparator()

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

        parent.AppendSeparator()

   260

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

   261

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

   262

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

   274

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

   275

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

   276

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

   277

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

   278

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

   279

   280

    def _RecursiveAddMenuItems(self, menu, items):

   281

        for name, text, help, children in items:

   282

            new_id = wx.NewId()

   283

            if len(children) > 0:

   284

                new_menu = wx.Menu(title='')

   285

                menu.AppendMenu(new_id, text, new_menu)

   286

                self._RecursiveAddMenuItems(new_menu, children)

   287

            else:

   288

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

   289

                           kind=wx.ITEM_NORMAL, text=text)

   290

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

   291

                          id=new_id)

   292

   293

    def _init_coll_AddMenu_Items(self, parent):

   294

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   295

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   296

   297

    def _init_coll_HelpMenu_Items(self, parent):

   298

        def handler(event):

   299

            return wx.MessageBox(

   300

                version.GetCommunityHelpMsg(),

   301

                _(u'Community support'),

   302

                wx.OK | wx.ICON_INFORMATION)

   303

   304

        id = wx.NewId()

   305

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

   306

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

   307

   308

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

   309

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

   310

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

   311

   312

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   313

        parent.SetFieldsCount(3)

   314

   315

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

   316

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

   317

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

   318

   319

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

   320

   321

    def _init_ctrls(self, prnt):

   322

        IDEFrame._init_ctrls(self, prnt)

   323

   324

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   325

   326

        inspectorID = wx.NewId()

   327

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

   328

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

   329

   330

        keyID = wx.NewId()

   331

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

   332

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

   333

   334

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

   335

                                 ("Run",      wx.WXK_F5),

   336

                                 ("Transfer", wx.WXK_F6),

   337

                                 ("Connect",  wx.WXK_F7),

   338

                                 ("Build",    wx.WXK_F11)]:

   339

            def OnMethodGen(obj, meth):

   340

                def OnMethod(evt):

   341

                    if obj.CTR is not None:

   342

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

   343

                    wx.CallAfter(self.RefreshStatusToolBar)

   344

                return OnMethod

   345

            newid = wx.NewId()

   346

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

   347

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

   348

   349

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   350

   351

        self.LogConsole = CustomStyledTextCtrl(

   352

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

   353

            size=wx.Size(0, 0))

   354

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

   355

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

   356

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

   357

        self.LogConsole.SetReadOnly(True)

   358

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

   359

   360

        # Define Log Console styles

   361

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

   362

        self.LogConsole.StyleClearAll()

   363

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

   364

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

   365

   366

        # Define Log Console markers

   367

        self.LogConsole.SetMarginSensitive(1, True)

   368

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

   369

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

   370

   371

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

   372

   373

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

   374

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

   375

   376

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

   377

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

   378

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

   379

   380

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

   381

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

   382

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

   383

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

   384

   385

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

   386

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

   387

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

   388

        StatusToolBar.Realize()

   389

        self.Panes["StatusToolBar"] = StatusToolBar

   390

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

   391

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

   392

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

   393

                                LeftDockable(False).RightDockable(False))

   394

   395

        self.AUIManager.Update()

   396

   397

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

   398

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   399

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

   400

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

   401

        self.ProgressStatusBar.Hide()

   402

        self.SetStatusBar(self.ConnectionStatusBar)

   403

   404

    def __init_execute_path(self):

   405

        if os.name == 'nt':

   406

            # on windows, desktop shortcut launches Beremiz.py

   407

            # with working dir set to mingw/bin.

   408

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

   409

            # commands invoked by build process by default are

   410

            # found here.

   411

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

   412

   413

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

   414

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

   415

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

   416

        self.__init_execute_path()

   417

   418

        IDEFrame.__init__(self, parent, debug)

   419

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

   420

   421

        self.local_runtime = None

   422

        self.runtime_port = None

   423

        self.local_runtime_tmpdir = None

   424

   425

        self.LastPanelSelected = None

   426

   427

        # Define Tree item icon list

   428

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

   429

        self.LocationImageDict = {}

   430

   431

        # Icons for location items

   432

        for imgname, itemtype in [

   433

                ("CONFIGURATION", LOCATION_CONFNODE),

   434

                ("RESOURCE",      LOCATION_MODULE),

   435

                ("PROGRAM",       LOCATION_GROUP),

   436

                ("VAR_INPUT",     LOCATION_VAR_INPUT),

   437

                ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   438

                ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   439

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

   440

   441

        # Icons for other items

   442

        for imgname, itemtype in [

   443

                ("Extension", ITEM_CONFNODE)]:

   444

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

   445

   446

        if projectOpen is not None:

   447

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   448

   449

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

   450

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

   451

            self.Controler = self.CTR

   452

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

   453

            if not result:

   454

                self.LibraryPanel.SetController(self.Controler)

   455

                self.ProjectTree.Enable(True)

   456

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   457

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

   458

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   459

            else:

   460

                self.ResetView()

   461

                self.ShowErrorMessage(result)

   462

        else:

   463

            self.CTR = ctr

   464

            self.Controler = ctr

   465

            if ctr is not None:

   466

                self.LibraryPanel.SetController(self.Controler)

   467

                self.ProjectTree.Enable(True)

   468

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   469

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   470

        if self.EnableDebug:

   471

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   472

   473

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

   474

   475

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

   476

        self.RefreshAll()

   477

        self.LogConsole.SetFocus()

   478

   479

    def RefreshTitle(self):

   480

        name = _("Beremiz")

   481

        if self.CTR is not None:

   482

            projectname = self.CTR.GetProjectName()

   483

            if self.CTR.ProjectTestModified():

   484

                projectname = "~%s~" % projectname

   485

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

   486

        else:

   487

            self.SetTitle(name)

   488

   489

    def StartLocalRuntime(self, taskbaricon=True):

   490

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

   491

            # create temporary directory for runtime working directory

   492

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   493

            # choose an arbitrary random port for runtime

   494

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

   495

            # launch local runtime

   496

            self.local_runtime = ProcessLogger(

   497

                self.Log,

   498

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

   499

                    sys.executable,

   500

                    Bpath("Beremiz_service.py"),

   501

                    self.runtime_port,

   502

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

   503

                    self.local_runtime_tmpdir),

   504

                no_gui=False,

   505

                timeout=500, keyword=self.local_runtime_tmpdir,

   506

                cwd=self.local_runtime_tmpdir)

   507

            self.local_runtime.spin()

   508

        return self.runtime_port

   509

   510

    def KillLocalRuntime(self):

   511

        if self.local_runtime is not None:

   512

            # shutdown local runtime