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

import wx.lib.buttons

    45

import wx.lib.statbmp

    46

import wx.stc

    47

import cPickle

    48

import types

    49

import time

    50

import re

    51

import platform

    52

import time

    53

import traceback

    54

import commands

    55

    56

from docutil import OpenHtmlFrame

    57

from editors.EditorPanel import EditorPanel

    58

from editors.Viewer import Viewer

    59

from editors.TextViewer import TextViewer

    60

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    61

from editors.DataTypeEditor import DataTypeEditor

    62

from util.MiniTextControler import MiniTextControler

    63

from util.ProcessLogger import ProcessLogger

    64

from controls.LogViewer import LogViewer

    65

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

    66

from controls import EnhancedStatusBar as esb

    67

from dialogs.AboutDialog import ShowAboutDialog

    68

    69

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

    70

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL, ITEM_CONFNODE

    71

    72

    73

MAX_RECENT_PROJECTS = 9

    74

    75

if wx.Platform == '__WXMSW__':

    76

    faces = {

    77

        'mono': 'Courier New',

    78

        'size': 8,

    79

    }

    80

else:

    81

    faces = {

    82

        'mono': 'Courier',

    83

        'size': 10,

    84

    }

    85

    86

from threading import Lock, Timer, currentThread

    87

MainThread = currentThread().ident

    88

REFRESH_PERIOD = 0.1

    89

from time import time as gettime

    90

    91

    92

class LogPseudoFile:

    93

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

    94

    def __init__(self, output, risecall):

    95

        self.red_white = 1

    96

        self.red_yellow = 2

    97

        self.black_white = wx.stc.STC_STYLE_DEFAULT

    98

        self.output = output

    99

        self.risecall = risecall

   100

        # to prevent rapid fire on rising log panel

   101

        self.rising_timer = 0

   102

        self.lock = Lock()

   103

        self.YieldLock = Lock()

   104

        self.RefreshLock = Lock()

   105

        self.TimerAccessLock = Lock()

   106

        self.stack = []

   107

        self.LastRefreshTime = gettime()

   108

        self.LastRefreshTimer = None

   109

   110

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

   111

        if self.lock.acquire():

   112

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

   113

            self.lock.release()

   114

            current_time = gettime()

   115

            self.TimerAccessLock.acquire()

   116

            if self.LastRefreshTimer:

   117

                self.LastRefreshTimer.cancel()

   119

            self.TimerAccessLock.release()

   120

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

   121

                self._should_write()

   122

            else:

   123

                self.TimerAccessLock.acquire()

   124

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

   125

                self.LastRefreshTimer.start()

   126

                self.TimerAccessLock.release()

   127

   128

    def _timer_expired(self):

   129

        if self.RefreshLock.acquire(False):

   130

            self._should_write()

   131

        else:

   132

            self.TimerAccessLock.acquire()

   133

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

   134

            self.LastRefreshTimer.start()

   135

            self.TimerAccessLock.release()

   136

   137

    def _should_write(self):

   138

        wx.CallAfter(self._write)

   139

        if MainThread == currentThread().ident:

   140

            app = wx.GetApp()

   141

            if app is not None:

   142

                if self.YieldLock.acquire(0):

   143

                    app.Yield()

   144

                    self.YieldLock.release()

   145

   146

    def _write(self):

   147

        if self.output:

   148

            self.output.Freeze()

   149

            self.lock.acquire()

   150

            for s, style in self.stack:

   152

                if style != self.black_white:

   153

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

   154

   155

                # Temporary deactivate read only mode on StyledTextCtrl for

   156

                # adding text. It seems that text modifications, even

   157

                # programmatically, are disabled in StyledTextCtrl when read

   158

                # only is active

   159

                start_pos = self.output.GetLength()

   160

                self.output.SetReadOnly(False)

   161

                self.output.AppendText(s)

   162

                self.output.SetReadOnly(True)

   163

                text_len = self.output.GetLength() - start_pos

   164

   165

                if style != self.black_white:

   166

                    self.output.SetStyling(text_len, style)

   167

            self.stack = []

   168

            self.lock.release()

   169

            self.output.Thaw()

   170

            self.LastRefreshTime = gettime()

   171

            try:

   172

                self.RefreshLock.release()

   173

            except:

   174

                pass

   175

            newtime = time.time()

   176

            if newtime - self.rising_timer > 1:

   177

                self.risecall(self.output)

   178

            self.rising_timer = newtime

   179

   180

    def write_warning(self, s):

   181

        self.write(s, self.red_white)

   182

   183

    def write_error(self, s):

   184

        self.write(s, self.red_yellow)

   185

   186

    def writeyield(self, s):

   187

        self.write(s)

   188

        wx.GetApp().Yield()

   189

   190

    def flush(self):

   191

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   192

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

   193

        # disabled in StyledTextCtrl when read only is active

   194

        self.output.SetReadOnly(False)

   195

        self.output.SetText("")

   196

        self.output.SetReadOnly(True)

   197

   198

    def isatty(self):

   199

        return False

   200

   201

ID_FILEMENURECENTPROJECTS = wx.NewId()

   202

   203

from IDEFrame import TITLE,\

   204

                     EDITORTOOLBAR,\

   205

                     FILEMENU,\

   206

                     EDITMENU,\

   207

                     DISPLAYMENU,\

   208

                     PROJECTTREE,\

   209

                     POUINSTANCEVARIABLESPANEL,\

   210

                     LIBRARYTREE,\

   211

                     SCALING,\

   212

                     PAGETITLES,\

   213

                     IDEFrame, AppendMenu,\

   214

                     EncodeFileSystemPath, DecodeFileSystemPath

   215

from util.BitmapLibrary import GetBitmap

   216

   217

   218

class Beremiz(IDEFrame):

   219

   220

    def _init_utils(self):

   221

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

   222

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

   223

   224

        IDEFrame._init_utils(self)

   225

   226

    def _init_coll_FileMenu_Items(self, parent):

   227

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

   228

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

   229

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

   230

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

   231

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

   232

        parent.AppendSeparator()

   233

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

   234

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

   235

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

   236

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

   237

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

   238

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

   239

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

   240

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

   241

        parent.AppendSeparator()

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

        parent.AppendSeparator()

   249

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

   250

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

   251

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

   263

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

   264

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

   265

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

   266

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

   267

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

   268

   269

    def _RecursiveAddMenuItems(self, menu, items):

   270

        for name, text, help, children in items:

   271

            new_id = wx.NewId()

   272

            if len(children) > 0:

   273

                new_menu = wx.Menu(title='')

   274

                menu.AppendMenu(new_id, text, new_menu)

   275

                self._RecursiveAddMenuItems(new_menu, children)

   276

            else:

   277

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

   278

                       kind=wx.ITEM_NORMAL, text=text)

   279

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

   280

                          id=new_id)

   281

   282

    def _init_coll_AddMenu_Items(self, parent):

   283

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   284

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   285

   286

    def _init_coll_HelpMenu_Items(self, parent):

   288

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

   289

        }

   290

        id = wx.NewId()

   291

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

   292

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

   293

   294

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

   295

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

   296

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

   297

   298

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   299

        parent.SetFieldsCount(3)

   300

   301

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

   302

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

   303

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

   304

   305

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

   306

   307

    def _init_ctrls(self, prnt):

   308

        IDEFrame._init_ctrls(self, prnt)

   309

   310

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   311

   312

        inspectorID = wx.NewId()

   313

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

   314

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

   315

   316

        keyID = wx.NewId()

   317

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

   318

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

   319

   320

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

   321

                                 ("Run",      wx.WXK_F5),

   322

                                 ("Transfer", wx.WXK_F6),

   323

                                 ("Connect",  wx.WXK_F7),

   324

                                 ("Build",    wx.WXK_F11)]:

   325

            def OnMethodGen(obj, meth):

   326

                def OnMethod(evt):

   327

                    if obj.CTR is not None:

   328

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

   329

                    wx.CallAfter(self.RefreshStatusToolBar)

   330

                return OnMethod

   331

            newid = wx.NewId()

   332

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

   333

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

   334

   335

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   336

   337

        self.LogConsole = CustomStyledTextCtrl(

   338

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

   339

                  size=wx.Size(0, 0))

   340

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

   341

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

   342

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

   343

        self.LogConsole.SetReadOnly(True)

   344

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

   345

   346

        # Define Log Console styles

   347

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

   348

        self.LogConsole.StyleClearAll()

   349

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

   350

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

   351

   352

        # Define Log Console markers

   353

        self.LogConsole.SetMarginSensitive(1, True)

   354

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

   355

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

   356

   357

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

   358

   359

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

   360

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

   361

   362

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

   363

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

   364

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

   365

   366

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

   367

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

   368

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

   369

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

   370

   371

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

   372

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

   373

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

   374

        StatusToolBar.Realize()

   375

        self.Panes["StatusToolBar"] = StatusToolBar

   376

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

   377

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

   378

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

   379

                  LeftDockable(False).RightDockable(False))

   380

   381

        self.AUIManager.Update()

   382

   383

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

   384

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   385

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

   386

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

   387

        self.ProgressStatusBar.Hide()

   388

        self.SetStatusBar(self.ConnectionStatusBar)

   389

   390

    def __init_execute_path(self):

   391

        if os.name == 'nt':

   392

            # on windows, desktop shortcut launches Beremiz.py

   393

            # with working dir set to mingw/bin.

   394

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

   395

            # commands invoked by build process by default are

   396

            # found here.

   397

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

   398

   399

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

   400

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

   401

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

   402

        self.__init_execute_path()

   403

   404

        IDEFrame.__init__(self, parent, debug)

   405

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

   406

   407

        self.local_runtime = None

   408

        self.runtime_port = None

   409

        self.local_runtime_tmpdir = None

   410

   411

        self.LastPanelSelected = None

   412

   413

        # Define Tree item icon list

   414

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

   415

        self.LocationImageDict = {}

   416

   417

        # Icons for location items

   418

        for imgname, itemtype in [

   419

            ("CONFIGURATION", LOCATION_CONFNODE),

   420

            ("RESOURCE",      LOCATION_MODULE),

   421

            ("PROGRAM",       LOCATION_GROUP),

   422

            ("VAR_INPUT",     LOCATION_VAR_INPUT),

   423

            ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   424

            ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   425

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

   426

   427

        # Icons for other items

   428

        for imgname, itemtype in [

   429

            ("Extension", ITEM_CONFNODE)]:

   430

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

   431

   432

        if projectOpen is not None:

   433

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   434

   435

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

   436

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

   437

            self.Controler = self.CTR

   438

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

   439

            if not result:

   440

                self.LibraryPanel.SetController(self.Controler)

   441

                self.ProjectTree.Enable(True)

   442

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   443

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

   444

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   445

            else:

   446

                self.ResetView()

   447

                self.ShowErrorMessage(result)

   448

        else:

   449

            self.CTR = ctr

   450

            self.Controler = ctr

   451

            if ctr is not None:

   452

                self.LibraryPanel.SetController(self.Controler)

   453

                self.ProjectTree.Enable(True)

   454

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   455

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   456

        if self.EnableDebug:

   457

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   458

   459

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

   460

   461

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

   462

        self.RefreshAll()

   463

        self.LogConsole.SetFocus()

   464

   465

    def RefreshTitle(self):

   466

        name = _("Beremiz")

   467

        if self.CTR is not None:

   468

            projectname = self.CTR.GetProjectName()

   469

            if self.CTR.ProjectTestModified():

   470

                projectname = "~%s~" % projectname

   471

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

   472

        else:

   473

            self.SetTitle(name)

   474

   475

    def StartLocalRuntime(self, taskbaricon = True):

   476

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

   477

            # create temporary directory for runtime working directory

   478

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   479

            # choose an arbitrary random port for runtime

   480

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

   481

            # launch local runtime

   482

            self.local_runtime = ProcessLogger(self.Log,

   483

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

   484

                    sys.executable,

   485

                    Bpath("Beremiz_service.py"),

   486

                    self.runtime_port,

   487

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

   488

                    self.local_runtime_tmpdir),

   489

                no_gui=False,

   490

                timeout=500, keyword = self.local_runtime_tmpdir,

   491

                cwd = self.local_runtime_tmpdir)

   492

            self.local_runtime.spin()

   493

        return self.runtime_port

   494

   495

    def KillLocalRuntime(self):

   496

        if self.local_runtime is not None:

   497

            # shutdown local runtime

   498

            self.local_runtime.kill(gently=False)

   499

            # clear temp dir

   500

            shutil.rmtree(self.local_runtime_tmpdir)

   501

   502

            self.local_runtime = None

   503

   504

    def OnOpenWidgetInspector(self, evt):

   505

        # Activate the widget inspection tool

   506

        from wx.lib.inspection import InspectionTool

   507

        if not InspectionTool().initialized:

   508

            InspectionTool().Init()

   509

   510

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

   511

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

   512

        wnd = wx.FindWindowAtPointer()

   513

        if not wnd:

   514

            wnd = self

   515

        InspectionTool().Show(wnd, True)

   516

   517

    def OnLogConsoleFocusChanged(self, event):

   518

        self.RefreshEditMenu()

   519

        event.Skip()

   520

   521

    def OnLogConsoleUpdateUI(self, event):

   522

        self.SetCopyBuffer(self.LogConsole.GetSelectedText(), True)