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

import util.paths as paths

    36

from types import ListType

    37

    38

beremiz_dir = paths.AbsDir(__file__)

    39

    40

    41

def Bpath(*args):

    42

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

    43

    44

    45

import wx.lib.buttons

    46

import wx.lib.statbmp

    47

import wx.stc

    48

import cPickle

    49

import types

    50

import time

    51

import re

    52

import platform

    53

import time

    54

import traceback

    55

import commands

    56

    57

from docutil import OpenHtmlFrame

    58

from editors.EditorPanel import EditorPanel

    59

from editors.Viewer import Viewer

    60

from editors.TextViewer import TextViewer

    61

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    62

from editors.DataTypeEditor import DataTypeEditor

    63

from util.MiniTextControler import MiniTextControler

    64

from util.ProcessLogger import ProcessLogger

    65

from controls.LogViewer import LogViewer

    66

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

    67

from controls import EnhancedStatusBar as esb

    68

from dialogs.AboutDialog import ShowAboutDialog

    69

    70

from PLCControler import LOCATION_CONFNODE, LOCATION_MODULE, LOCATION_GROUP, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY, ITEM_PROJECT, ITEM_RESOURCE

    71

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL, ITEM_CONFNODE

    72

    73

    74

MAX_RECENT_PROJECTS = 9

    75

    76

if wx.Platform == '__WXMSW__':

    77

    faces = {

    78

        'mono': 'Courier New',

    79

        'size': 8,

    80

    }

    81

else:

    82

    faces = {

    83

        'mono': 'Courier',

    84

        'size': 10,

    85

    }

    86

    87

from threading import Lock, Timer, currentThread

    88

MainThread = currentThread().ident

    89

REFRESH_PERIOD = 0.1

    90

from time import time as gettime

    91

    92

    93

class LogPseudoFile:

    94

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

    95

    def __init__(self, output, risecall):

    96

        self.red_white = 1

    97

        self.red_yellow = 2

    98

        self.black_white = wx.stc.STC_STYLE_DEFAULT

    99

        self.output = output

   100

        self.risecall = risecall

   101

        # to prevent rapid fire on rising log panel

   102

        self.rising_timer = 0

   103

        self.lock = Lock()

   104

        self.YieldLock = Lock()

   105

        self.RefreshLock = Lock()

   106

        self.TimerAccessLock = Lock()

   107

        self.stack = []

   108

        self.LastRefreshTime = gettime()

   109

        self.LastRefreshTimer = None

   110

   111

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

   112

        if self.lock.acquire():

   113

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

   114

            self.lock.release()

   115

            current_time = gettime()

   116

            self.TimerAccessLock.acquire()

   117

            if self.LastRefreshTimer:

   118

                self.LastRefreshTimer.cancel()

   119

                self.LastRefreshTimer = None

   120

            self.TimerAccessLock.release()

   121

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

   122

                self._should_write()

   123

            else:

   124

                self.TimerAccessLock.acquire()

   125

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

   126

                self.LastRefreshTimer.start()

   127

                self.TimerAccessLock.release()

   128

   129

    def _timer_expired(self):

   130

        if self.RefreshLock.acquire(False):

   131

            self._should_write()

   132

        else:

   133

            self.TimerAccessLock.acquire()

   134

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

   135

            self.LastRefreshTimer.start()

   136

            self.TimerAccessLock.release()

   137

   138

    def _should_write(self):

   139

        wx.CallAfter(self._write)

   140

        if MainThread == currentThread().ident:

   141

            app = wx.GetApp()

   142

            if app is not None:

   143

                if self.YieldLock.acquire(0):

   144

                    app.Yield()

   145

                    self.YieldLock.release()

   146

   147

    def _write(self):

   148

        if self.output:

   149

            self.output.Freeze()

   150

            self.lock.acquire()

   151

            for s, style in self.stack:

   152

                if style is None:

   153

                    style = self.black_white

   154

                if style != self.black_white:

   155

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

   156

   157

                # Temporary deactivate read only mode on StyledTextCtrl for

   158

                # adding text. It seems that text modifications, even

   159

                # programmatically, are disabled in StyledTextCtrl when read

   160

                # only is active

   161

                start_pos = self.output.GetLength()

   162

                self.output.SetReadOnly(False)

   163

                self.output.AppendText(s)

   164

                self.output.SetReadOnly(True)

   165

                text_len = self.output.GetLength() - start_pos

   166

   167

                if style != self.black_white:

   168

                    self.output.SetStyling(text_len, style)

   169

            self.stack = []

   170

            self.lock.release()

   171

            self.output.Thaw()

   172

            self.LastRefreshTime = gettime()

   173

            try:

   174

                self.RefreshLock.release()

   175

            except:

   176

                pass

   177

            newtime = time.time()

   178

            if newtime - self.rising_timer > 1:

   179

                self.risecall(self.output)

   180

            self.rising_timer = newtime

   181

   182

    def write_warning(self, s):

   183

        self.write(s, self.red_white)

   184

   185

    def write_error(self, s):

   186

        self.write(s, self.red_yellow)

   187

   188

    def writeyield(self, s):

   189

        self.write(s)

   190

        wx.GetApp().Yield()

   191

   192

    def flush(self):

   193

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   194

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

   195

        # disabled in StyledTextCtrl when read only is active

   196

        self.output.SetReadOnly(False)

   197

        self.output.SetText("")

   198

        self.output.SetReadOnly(True)

   199

   200

    def isatty(self):

   201

        return False

   202

   203

   204

ID_FILEMENURECENTPROJECTS = wx.NewId()

   205

   206

from IDEFrame import TITLE,\

   207

                     EDITORTOOLBAR,\

   208

                     FILEMENU,\

   209

                     EDITMENU,\

   210

                     DISPLAYMENU,\

   211

                     PROJECTTREE,\

   212

                     POUINSTANCEVARIABLESPANEL,\

   213

                     LIBRARYTREE,\

   214

                     SCALING,\

   215

                     PAGETITLES,\

   216

                     IDEFrame, AppendMenu,\

   217

                     EncodeFileSystemPath, DecodeFileSystemPath

   218

from util.BitmapLibrary import GetBitmap

   219

   220

   221

class Beremiz(IDEFrame):

   222

   223

    def _init_utils(self):

   224

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

   225

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

   226

   227

        IDEFrame._init_utils(self)

   228

   229

    def _init_coll_FileMenu_Items(self, parent):

   230

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

   231

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

   232

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

   233

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

   234

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

   235

        parent.AppendSeparator()

   236

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

   237

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

   238

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

   239

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

   240

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

   241

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

   242

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

   243

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

   244

        parent.AppendSeparator()

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

        parent.AppendSeparator()

   252

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

   253

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

   254

   255

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

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

   266

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

   267

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

   268

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

   269

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

   270

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

   271

   272

    def _RecursiveAddMenuItems(self, menu, items):

   273

        for name, text, help, children in items:

   274

            new_id = wx.NewId()

   275

            if len(children) > 0:

   276

                new_menu = wx.Menu(title='')

   277

                menu.AppendMenu(new_id, text, new_menu)

   278

                self._RecursiveAddMenuItems(new_menu, children)

   279

            else:

   280

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

   281

                       kind=wx.ITEM_NORMAL, text=text)

   282

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

   283

                          id=new_id)

   284

   285

    def _init_coll_AddMenu_Items(self, parent):

   286

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   287

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   288

   289

    def _init_coll_HelpMenu_Items(self, parent):

   290

        handler = lambda event: {

   291

            wx.MessageBox(version.GetCommunityHelpMsg(), _(u'Community support'), wx.OK | wx.ICON_INFORMATION)

   292

        }

   293

        id = wx.NewId()

   294

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

   295

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

   296

   297

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

   298

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

   299

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

   300

   301

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   302

        parent.SetFieldsCount(3)

   303

   304

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

   305

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

   306

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

   307

   308

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

   309

   310

    def _init_ctrls(self, prnt):

   311

        IDEFrame._init_ctrls(self, prnt)

   312

   313

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   314

   315

        inspectorID = wx.NewId()

   316

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

   317

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

   318

   319

        keyID = wx.NewId()

   320

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

   321

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

   322

   323

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

   324

                                 ("Run",      wx.WXK_F5),

   325

                                 ("Transfer", wx.WXK_F6),

   326

                                 ("Connect",  wx.WXK_F7),

   327

                                 ("Build",    wx.WXK_F11)]:

   328

            def OnMethodGen(obj, meth):

   329

                def OnMethod(evt):

   330

                    if obj.CTR is not None:

   331

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

   332

                    wx.CallAfter(self.RefreshStatusToolBar)

   333

                return OnMethod

   334

            newid = wx.NewId()

   335

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

   336

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

   337

   338

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   339

   340

        self.LogConsole = CustomStyledTextCtrl(

   341

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

   342

                  size=wx.Size(0, 0))

   343

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

   344

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

   345

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

   346

        self.LogConsole.SetReadOnly(True)

   347

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

   348

   349

        # Define Log Console styles

   350

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

   351

        self.LogConsole.StyleClearAll()

   352

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

   353

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

   354

   355

        # Define Log Console markers

   356

        self.LogConsole.SetMarginSensitive(1, True)

   357

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

   358

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

   359

   360

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

   361

   362

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

   363

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

   364

   365

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

   366

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

   367

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

   368

   369

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

   370

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

   371

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

   372

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

   373

   374

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

   375

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

   376

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

   377

        StatusToolBar.Realize()

   378

        self.Panes["StatusToolBar"] = StatusToolBar

   379

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

   380

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

   381

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

   382

                  LeftDockable(False).RightDockable(False))

   383

   384

        self.AUIManager.Update()

   385

   386

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

   387

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   388

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

   389

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

   390

        self.ProgressStatusBar.Hide()

   391

        self.SetStatusBar(self.ConnectionStatusBar)

   392

   393

    def __init_execute_path(self):

   394

        if os.name == 'nt':

   395

            # on windows, desktop shortcut launches Beremiz.py

   396

            # with working dir set to mingw/bin.

   397

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

   398

            # commands invoked by build process by default are

   399

            # found here.

   400

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

   401

   402

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

   403

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

   404

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

   405

        self.__init_execute_path()

   406

   407

        IDEFrame.__init__(self, parent, debug)

   408

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

   409

   410

        self.local_runtime = None

   411

        self.runtime_port = None

   412

        self.local_runtime_tmpdir = None

   413

   414

        self.LastPanelSelected = None

   415

   416

        # Define Tree item icon list

   417

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

   418

        self.LocationImageDict = {}

   419

   420

        # Icons for location items

   421

        for imgname, itemtype in [

   422

            ("CONFIGURATION", LOCATION_CONFNODE),

   423

            ("RESOURCE",      LOCATION_MODULE),

   424

            ("PROGRAM",       LOCATION_GROUP),

   425

            ("VAR_INPUT",     LOCATION_VAR_INPUT),

   426

            ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   427

            ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   428

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

   429

   430

        # Icons for other items

   431

        for imgname, itemtype in [

   432

            ("Extension", ITEM_CONFNODE)]:

   433

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

   434

   435

        if projectOpen is not None:

   436

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   437

   438

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

   439

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

   440

            self.Controler = self.CTR

   441

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

   442

            if not result:

   443

                self.LibraryPanel.SetController(self.Controler)

   444

                self.ProjectTree.Enable(True)

   445

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   446

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

   447

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   448

            else:

   449

                self.ResetView()

   450

                self.ShowErrorMessage(result)

   451

        else:

   452

            self.CTR = ctr

   453

            self.Controler = ctr

   454

            if ctr is not None:

   455

                self.LibraryPanel.SetController(self.Controler)

   456

                self.ProjectTree.Enable(True)

   457

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   458

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   459

        if self.EnableDebug:

   460

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   461

   462

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

   463

   464

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

   465

        self.RefreshAll()

   466

        self.LogConsole.SetFocus()

   467

   468

    def RefreshTitle(self):

   469

        name = _("Beremiz")

   470

        if self.CTR is not None:

   471

            projectname = self.CTR.GetProjectName()

   472

            if self.CTR.ProjectTestModified():

   473

                projectname = "~%s~" % projectname

   474

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

   475

        else:

   476

            self.SetTitle(name)

   477

   478

    def StartLocalRuntime(self, taskbaricon=True):

   479

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

   480

            # create temporary directory for runtime working directory

   481

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   482

            # choose an arbitrary random port for runtime

   483

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

   484

            # launch local runtime

   485

            self.local_runtime = ProcessLogger(self.Log,

   486

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

   487

                    sys.executable,

   488

                    Bpath("Beremiz_service.py"),

   489

                    self.runtime_port,

   490

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

   491

                    self.local_runtime_tmpdir),

   492

                no_gui=False,

   493

                timeout=500, keyword=self.local_runtime_tmpdir,

   494

                cwd=self.local_runtime_tmpdir)

   495

            self.local_runtime.spin()

   496

        return self.runtime_port

   497

   498

    def KillLocalRuntime(self):

   499

        if self.local_runtime is not None:

   500

            # shutdown local runtime

   501

            self.local_runtime.kill(gently=False)

   502

            # clear temp dir

   503

            shutil.rmtree(self.local_runtime_tmpdir)

   504

   505

            self.local_runtime = None

   506

   507

    def OnOpenWidgetInspector(self, evt):

   508

        # Activate the widget inspection tool

   509

        from wx.lib.inspection import InspectionTool

   510

        if not InspectionTool().initialized:

   511

            InspectionTool().Init()

   512

   513

        # Find a widget to be selected in the tree.  Use either the

   514

        # one under the cursor, if any, or this frame.

   515

        wnd = wx.FindWindowAtPointer()

   516

        if not wnd:

   517

            wnd = self

   518

        InspectionTool().Show(wnd, True)

   519

   520

    def OnLogConsoleFocusChanged(self, event):

   521