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 time

    33

import version

    34

    35

from types import ListType

    36

    37

import wx.lib.buttons

    38

import wx.lib.statbmp

    39

import wx.stc

    40

import cPickle

    41

import types

    42

import re

    43

import commands

    44

from threading import Lock, Timer, currentThread

    45

from time import time as gettime

    46

    47

import util.paths as paths

    48

from docutil import OpenHtmlFrame

    49

from editors.EditorPanel import EditorPanel

    50

from editors.Viewer import Viewer

    51

from editors.TextViewer import TextViewer

    52

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    53

from editors.DataTypeEditor import DataTypeEditor

    54

from util.MiniTextControler import MiniTextControler

    55

from util.ProcessLogger import ProcessLogger

    56

from controls.LogViewer import LogViewer

    57

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

    58

from controls import EnhancedStatusBar as esb

    59

from dialogs.AboutDialog import ShowAboutDialog

    60

    61

from PLCControler import \

    62

    LOCATION_CONFNODE, \

    63

    LOCATION_MODULE, \

    64

    LOCATION_GROUP, \

    65

    LOCATION_VAR_INPUT, \

    66

    LOCATION_VAR_OUTPUT, \

    67

    LOCATION_VAR_MEMORY, \

    68

    ITEM_PROJECT, \

    69

    ITEM_RESOURCE

    70

    71

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL, ITEM_CONFNODE

    72

    73

from IDEFrame import \

    74

    TITLE,\

    75

    EDITORTOOLBAR,\

    76

    FILEMENU,\

    77

    EDITMENU,\

    78

    DISPLAYMENU,\

    79

    PROJECTTREE,\

    80

    POUINSTANCEVARIABLESPANEL,\

    81

    LIBRARYTREE,\

    82

    SCALING,\

    83

    PAGETITLES,\

    84

    IDEFrame, \

    85

    AppendMenu,\

    86

    EncodeFileSystemPath, \

    87

    DecodeFileSystemPath

    88

    89

from util.BitmapLibrary import GetBitmap

    90

    91

    92

beremiz_dir = paths.AbsDir(__file__)

    93

    94

    95

def Bpath(*args):

    96

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

    97

    98

    99

MAX_RECENT_PROJECTS = 9

   100

   101

   102

if wx.Platform == '__WXMSW__':

   103

    faces = {

   104

        'mono': 'Courier New',

   105

        'size': 8,

   106

    }

   107

else:

   108

    faces = {

   109

        'mono': 'Courier',

   110

        'size': 10,

   111

    }

   112

   113

   114

MainThread = currentThread().ident

   115

REFRESH_PERIOD = 0.1

   116

   117

   119

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

   120

    def __init__(self, output, risecall):

   121

        self.red_white = 1

   122

        self.red_yellow = 2

   123

        self.black_white = wx.stc.STC_STYLE_DEFAULT

   124

        self.output = output

   125

        self.risecall = risecall

   126

        # to prevent rapid fire on rising log panel

   127

        self.rising_timer = 0

   128

        self.lock = Lock()

   129

        self.YieldLock = Lock()

   130

        self.RefreshLock = Lock()

   131

        self.TimerAccessLock = Lock()

   132

        self.stack = []

   133

        self.LastRefreshTime = gettime()

   134

        self.LastRefreshTimer = None

   135

   136

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

   137

        if self.lock.acquire():

   138

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

   139

            self.lock.release()

   140

            current_time = gettime()

   141

            self.TimerAccessLock.acquire()

   142

            if self.LastRefreshTimer:

   143

                self.LastRefreshTimer.cancel()

   144

                self.LastRefreshTimer = None

   145

            self.TimerAccessLock.release()

   146

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

   147

                self._should_write()

   148

            else:

   149

                self.TimerAccessLock.acquire()

   150

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

   151

                self.LastRefreshTimer.start()

   152

                self.TimerAccessLock.release()

   153

   154

    def _timer_expired(self):

   155

        if self.RefreshLock.acquire(False):

   156

            self._should_write()

   157

        else:

   158

            self.TimerAccessLock.acquire()

   159

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

   160

            self.LastRefreshTimer.start()

   161

            self.TimerAccessLock.release()

   162

   163

    def _should_write(self):

   164

        app = wx.GetApp()

   165

        if app is not None:

   166

            wx.CallAfter(self._write)

   167

   168

        if MainThread == currentThread().ident:

   169

            if app is not None:

   170

                if self.YieldLock.acquire(0):

   171

                    app.Yield()

   172

                    self.YieldLock.release()

   173

   174

    def _write(self):

   175

        if self.output:

   176

            self.output.Freeze()

   177

            self.lock.acquire()

   178

            for s, style in self.stack:

   179

                if style is None:

   180

                    style = self.black_white

   181

                if style != self.black_white:

   182

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

   183

   184

                # Temporary deactivate read only mode on StyledTextCtrl for

   185

                # adding text. It seems that text modifications, even

   186

                # programmatically, are disabled in StyledTextCtrl when read

   187

                # only is active

   188

                start_pos = self.output.GetLength()

   189

                self.output.SetReadOnly(False)

   190

                self.output.AppendText(s)

   191

                self.output.SetReadOnly(True)

   192

                text_len = self.output.GetLength() - start_pos

   193

   194

                if style != self.black_white:

   195

                    self.output.SetStyling(text_len, style)

   196

            self.stack = []

   197

            self.lock.release()

   198

            self.output.Thaw()

   199

            self.LastRefreshTime = gettime()

   200

            try:

   201

                self.RefreshLock.release()

   202

            except Exception:

   203

                pass

   204

            newtime = time.time()

   205

            if newtime - self.rising_timer > 1:

   206

                self.risecall(self.output)

   207

            self.rising_timer = newtime

   208

   209

    def write_warning(self, s):

   210

        self.write(s, self.red_white)

   211

   212

    def write_error(self, s):

   213

        self.write(s, self.red_yellow)

   214

   215

    def writeyield(self, s):

   216

        self.write(s)

   217

        wx.GetApp().Yield()

   218

   219

    def flush(self):

   220

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   221

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

   222

        # disabled in StyledTextCtrl when read only is active

   223

        self.output.SetReadOnly(False)

   224

        self.output.SetText("")

   225

        self.output.SetReadOnly(True)

   226

   227

    def isatty(self):

   228

        return False

   229

   230

   231

ID_FILEMENURECENTPROJECTS = wx.NewId()

   232

   233

   234

class Beremiz(IDEFrame):

   235

   236

    def _init_utils(self):

   237

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

   238

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

   239

   240

        IDEFrame._init_utils(self)

   241

   242

    def _init_coll_FileMenu_Items(self, parent):

   243

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

   244

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

   245

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

   246

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

   247

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

   248

        parent.AppendSeparator()

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

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

   257

        parent.AppendSeparator()

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

        parent.AppendSeparator()

   265

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

   266

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

   267

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

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

   275

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

   276

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

   277

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

   278

   279

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

   280

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

   281

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

   282

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

   283

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

   284

   285

    def _RecursiveAddMenuItems(self, menu, items):

   286

        for name, text, help, children in items:

   287

            new_id = wx.NewId()

   288

            if len(children) > 0:

   289

                new_menu = wx.Menu(title='')

   290

                menu.AppendMenu(new_id, text, new_menu)

   291

                self._RecursiveAddMenuItems(new_menu, children)

   292

            else:

   293

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

   294

                           kind=wx.ITEM_NORMAL, text=text)

   295

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

   296

                          id=new_id)

   297

   298

    def _init_coll_AddMenu_Items(self, parent):

   299

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   300

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   301

   302

    def _init_coll_HelpMenu_Items(self, parent):

   303

        def handler(event):

   304

            return wx.MessageBox(

   305

                version.GetCommunityHelpMsg(),

   306

                _(u'Community support'),

   307

                wx.OK | wx.ICON_INFORMATION)

   308

   309

        id = wx.NewId()

   310

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

   311

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

   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

        keyID = wx.NewId()

   336

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

   337

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

   338

   339

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

   340

                                 ("Run",      wx.WXK_F5),

   341

                                 ("Transfer", wx.WXK_F6),

   342

                                 ("Connect",  wx.WXK_F7),

   343

                                 ("Build",    wx.WXK_F11)]:

   344

            def OnMethodGen(obj, meth):

   345

                def OnMethod(evt):

   346

                    if obj.CTR is not None:

   347

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

   348

                    wx.CallAfter(self.RefreshStatusToolBar)

   349

                return OnMethod

   350

            newid = wx.NewId()

   351

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

   352

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

   353

   354

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   355

   356

        self.LogConsole = CustomStyledTextCtrl(

   357

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

   358

                  size=wx.Size(0, 0))

   359

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

   360

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

   361

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

   362

        self.LogConsole.SetReadOnly(True)

   363

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

   364

   365

        # Define Log Console styles

   366

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

   367

        self.LogConsole.StyleClearAll()

   368

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

   369

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

   370

   371

        # Define Log Console markers

   372

        self.LogConsole.SetMarginSensitive(1, True)

   373

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

   374

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

   375

   376

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

   377

   378

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

   379

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

   380

   381

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

   382

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

   383

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

   384

   385

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

   386

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

   387

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

   388

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

   389

   390

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

   391

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

   392

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

   393

        StatusToolBar.Realize()

   394

        self.Panes["StatusToolBar"] = StatusToolBar

   395

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

   396

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

   397

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

   398

                                LeftDockable(False).RightDockable(False))

   399

   400

        self.AUIManager.Update()

   401

   402

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

   403

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   404

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

   405

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

   406

        self.ProgressStatusBar.Hide()

   407

        self.SetStatusBar(self.ConnectionStatusBar)

   408

   409

    def __init_execute_path(self):

   410

        if os.name == 'nt':

   411

            # on windows, desktop shortcut launches Beremiz.py

   412

            # with working dir set to mingw/bin.

   413

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

   414

            # commands invoked by build process by default are

   415

            # found here.

   416

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

   417

   418

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

   419

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

   420

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

   421

        self.__init_execute_path()

   422

   423

        IDEFrame.__init__(self, parent, debug)

   424

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

   425

   426

        self.local_runtime = None

   427

        self.runtime_port = None

   428

        self.local_runtime_tmpdir = None

   429

   430

        self.LastPanelSelected = None

   431

   432

        # Define Tree item icon list

   433

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

   434

        self.LocationImageDict = {}

   435

   436

        # Icons for location items

   437

        for imgname, itemtype in [

   438

                ("CONFIGURATION", LOCATION_CONFNODE),

   439

                ("RESOURCE",      LOCATION_MODULE),

   440

                ("PROGRAM",       LOCATION_GROUP),

   441

                ("VAR_INPUT",     LOCATION_VAR_INPUT),

   442

                ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   443

                ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   444

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

   445

   446

        # Icons for other items

   447

        for imgname, itemtype in [

   448

                ("Extension", ITEM_CONFNODE)]:

   449

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

   450

   451

        if projectOpen is not None:

   452

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   453

   454

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

   455

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

   456

            self.Controler = self.CTR

   457

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

   458

            if not result:

   459

                self.LibraryPanel.SetController(self.Controler)

   460

                self.ProjectTree.Enable(True)

   461

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   462

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

   463

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   464

            else:

   465

                self.ResetView()

   466

                self.ShowErrorMessage(result)

   467

        else:

   468

            self.CTR = ctr

   469

            self.Controler = ctr

   470

            if ctr is not None:

   471

                self.LibraryPanel.SetController(self.Controler)

   472

                self.ProjectTree.Enable(True)

   473

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   474

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   475

        if self.EnableDebug:

   476

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   477

   478

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

   479

   480

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

   481

        self.RefreshAll()

   482

        self.LogConsole.SetFocus()

   483

   484

    def RefreshTitle(self):

   485

        name = _("Beremiz")

   486

        if self.CTR is not None:

   487

            projectname = self.CTR.GetProjectName()

   488

            if self.CTR.ProjectTestModified():

   489

                projectname = "~%s~" % projectname

   490

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

   491

        else:

   492

            self.SetTitle(name)

   493

   494

    def StartLocalRuntime(self, taskbaricon=True):

   495

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

   496

            # create temporary directory for runtime working directory

   497

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   498

            # choose an arbitrary random port for runtime

   499

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

   500

            # launch local runtime

   501

            self.local_runtime = ProcessLogger(

   502

                self.Log,

   503

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

   504

                    sys.executable,

   505

                    Bpath("Beremiz_service.py"),

   506

                    self.runtime_port,

   507

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

   508

                    self.local_runtime_tmpdir),

   509

                no_gui=False,

   510

                timeout=500, keyword=self.local_runtime_tmpdir,

   511

                cwd=self.local_runtime_tmpdir)

   512

            self.local_runtime.spin()

   513

        return self.runtime_port