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, sys

    28

import tempfile

    29

import shutil

    30

import random

    31

import time

    32

import version

    33

import util.paths as paths

    34

from types import ListType

    35

    36

beremiz_dir = paths.AbsDir(__file__)

    37

    38

def Bpath(*args):

    39

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

    40

    41

    42

    43

import wx.lib.buttons, wx.lib.statbmp, wx.stc

    44

import cPickle

    45

import types, time, re, platform, time, traceback, commands

    46

    47

from docutil import OpenHtmlFrame

    48

from editors.EditorPanel import EditorPanel

    49

from editors.Viewer import Viewer

    50

from editors.TextViewer import TextViewer

    51

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    52

from editors.DataTypeEditor import DataTypeEditor

    53

from util.MiniTextControler import MiniTextControler

    54

from util.ProcessLogger import ProcessLogger

    55

from controls.LogViewer import LogViewer

    56

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

    57

from controls import EnhancedStatusBar as esb

    58

from dialogs.AboutDialog import ShowAboutDialog

    59

    60

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

    61

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL, ITEM_CONFNODE

    62

    63

    64

MAX_RECENT_PROJECTS = 9

    65

    66

if wx.Platform == '__WXMSW__':

    67

    faces = {

    68

        'mono' : 'Courier New',

    69

        'size' : 8,

    70

    }

    71

else:

    72

    faces = {

    73

        'mono' : 'Courier',

    74

        'size' : 10,

    75

    }

    76

    77

from threading import Lock,Timer,currentThread

    78

MainThread = currentThread().ident

    79

REFRESH_PERIOD = 0.1

    80

from time import time as gettime

    81

class LogPseudoFile:

    82

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

    83

    def __init__(self, output, risecall):

    84

        self.red_white = 1

    85

        self.red_yellow = 2

    86

        self.black_white = wx.stc.STC_STYLE_DEFAULT

    87

        self.output = output

    88

        self.risecall = risecall

    89

        # to prevent rapid fire on rising log panel

    90

        self.rising_timer = 0

    91

        self.lock = Lock()

    92

        self.YieldLock = Lock()

    93

        self.RefreshLock = Lock()

    94

        self.TimerAccessLock = Lock()

    95

        self.stack = []

    96

        self.LastRefreshTime = gettime()

    97

        self.LastRefreshTimer = None

    98

    99

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

   100

        if self.lock.acquire():

   101

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

   102

            self.lock.release()

   103

            current_time = gettime()

   104

            self.TimerAccessLock.acquire()

   105

            if self.LastRefreshTimer:

   106

                self.LastRefreshTimer.cancel()

   107

                self.LastRefreshTimer=None

   108

            self.TimerAccessLock.release()

   109

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

   110

                self._should_write()

   111

            else:

   112

                self.TimerAccessLock.acquire()

   113

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

   114

                self.LastRefreshTimer.start()

   115

                self.TimerAccessLock.release()

   116

   117

    def _timer_expired(self):

   118

        if self.RefreshLock.acquire(False):

   119

            self._should_write()

   120

        else:

   121

            self.TimerAccessLock.acquire()

   122

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

   123

            self.LastRefreshTimer.start()

   124

            self.TimerAccessLock.release()

   125

   126

    def _should_write(self):

   127

        wx.CallAfter(self._write)

   128

        if MainThread == currentThread().ident:

   129

            app = wx.GetApp()

   130

            if app is not None:

   131

                if self.YieldLock.acquire(0):

   132

                    app.Yield()

   133

                    self.YieldLock.release()

   134

   135

    def _write(self):

   136

        if self.output :

   137

            self.output.Freeze()

   138

            self.lock.acquire()

   139

            for s, style in self.stack:

   140

                if style is None : style=self.black_white

   141

                if style != self.black_white:

   142

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

   143

   144

                # Temporary deactivate read only mode on StyledTextCtrl for

   145

                # adding text. It seems that text modifications, even

   146

                # programmatically, are disabled in StyledTextCtrl when read

   147

                # only is active

   148

                start_pos = self.output.GetLength()

   149

                self.output.SetReadOnly(False)

   150

                self.output.AppendText(s)

   151

                self.output.SetReadOnly(True)

   152

                text_len = self.output.GetLength() - start_pos

   153

   154

                if style != self.black_white:

   155

                    self.output.SetStyling(text_len, style)

   156

            self.stack = []

   157

            self.lock.release()

   158

            self.output.Thaw()

   159

            self.LastRefreshTime = gettime()

   160

            try:

   161

                self.RefreshLock.release()

   162

            except:

   163

                pass

   164

            newtime = time.time()

   165

            if newtime - self.rising_timer > 1:

   166

                self.risecall(self.output)

   167

            self.rising_timer = newtime

   168

   169

    def write_warning(self, s):

   170

        self.write(s,self.red_white)

   171

   172

    def write_error(self, s):

   173

        self.write(s,self.red_yellow)

   174

   175

    def writeyield(self, s):

   176

        self.write(s)

   177

        wx.GetApp().Yield()

   178

   179

    def flush(self):

   180

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   181

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

   182

        # disabled in StyledTextCtrl when read only is active

   183

        self.output.SetReadOnly(False)

   184

        self.output.SetText("")

   185

        self.output.SetReadOnly(True)

   186

   187

    def isatty(self):

   188

        return False

   189

   190

ID_FILEMENURECENTPROJECTS = wx.NewId()

   191

   192

from IDEFrame import TITLE,\

   193

                     EDITORTOOLBAR,\

   194

                     FILEMENU,\

   195

                     EDITMENU,\

   196

                     DISPLAYMENU,\

   197

                     PROJECTTREE,\

   198

                     POUINSTANCEVARIABLESPANEL,\

   199

                     LIBRARYTREE,\

   200

                     SCALING,\

   201

                     PAGETITLES,\

   202

                     IDEFrame, AppendMenu,\

   203

                     EncodeFileSystemPath, DecodeFileSystemPath

   204

from util.BitmapLibrary import GetBitmap

   205

   206

class Beremiz(IDEFrame):

   207

   208

    def _init_utils(self):

   209

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

   210

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

   211

   212

        IDEFrame._init_utils(self)

   213

   214

    def _init_coll_FileMenu_Items(self, parent):

   215

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

   216

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

   217

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

   218

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

   219

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

   220

        parent.AppendSeparator()

   221

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

   222

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

   223

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

   224

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

   225

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

   226

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

   227

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

   228

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

   229

        parent.AppendSeparator()

   230

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

   231

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

   232

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

   233

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

   234

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

   235

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

   236

        parent.AppendSeparator()

   237

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

   238

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

   239

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

   251

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

   252

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

   253

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

   254

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

   255

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

   256

   257

    def _RecursiveAddMenuItems(self, menu, items):

   258

        for name, text, help, children in items:

   259

            new_id = wx.NewId()

   260

            if len(children) > 0:

   261

                new_menu = wx.Menu(title='')

   262

                menu.AppendMenu(new_id, text, new_menu)

   263

                self._RecursiveAddMenuItems(new_menu, children)

   264

            else:

   265

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

   266

                       kind=wx.ITEM_NORMAL, text=text)

   267

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

   268

                          id=new_id)

   269

   270

    def _init_coll_AddMenu_Items(self, parent):

   271

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   272

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   273

   274

    def _init_coll_HelpMenu_Items(self, parent):

   275

        handler=lambda event: {

   276

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

   277

        }

   278

        id = wx.NewId()

   279

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

   280

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

   281

   282

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

   283

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

   284

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

   285

   286

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   287

        parent.SetFieldsCount(3)

   288

   289

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

   290

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

   291

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

   292

   293

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

   294

   295

    def _init_ctrls(self, prnt):

   296

        IDEFrame._init_ctrls(self, prnt)

   297

   298

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   299

   300

        inspectorID = wx.NewId()

   301

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

   302

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

   303

   304

        keyID = wx.NewId()

   305

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

   306

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

   307

   308

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

   309

                                ("Run",      wx.WXK_F5),

   310

                                ("Transfer", wx.WXK_F6),

   311

                                ("Connect",  wx.WXK_F7),

   312

                                ("Build",    wx.WXK_F11)]:

   313

            def OnMethodGen(obj,meth):

   314

                def OnMethod(evt):

   315

                    if obj.CTR is not None:

   316

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

   317

                    wx.CallAfter(self.RefreshStatusToolBar)

   318

                return OnMethod

   319

            newid = wx.NewId()

   320

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

   321

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

   322

   323

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   324

   325

        self.LogConsole = CustomStyledTextCtrl(

   326

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

   327

                  size=wx.Size(0, 0))

   328

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

   329

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

   330

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

   331

        self.LogConsole.SetReadOnly(True)

   332

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

   333

   334

        # Define Log Console styles

   335

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

   336

        self.LogConsole.StyleClearAll()

   337

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

   338

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

   339

   340

        # Define Log Console markers

   341

        self.LogConsole.SetMarginSensitive(1, True)

   342

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

   343

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

   344

   345

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

   346

   347

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

   348

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

   349

   350

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

   351

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

   352

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

   353

   354

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

   355

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

   356

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

   357

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

   358

   359

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

   360

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

   361

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

   362

        StatusToolBar.Realize()

   363

        self.Panes["StatusToolBar"] = StatusToolBar

   364

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

   365

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

   366

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

   367

                  LeftDockable(False).RightDockable(False))

   368

   369

        self.AUIManager.Update()

   370

   371

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

   372

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   373

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

   374

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

   375

        self.ProgressStatusBar.Hide()

   376

        self.SetStatusBar(self.ConnectionStatusBar)

   377

   378

    def __init_execute_path(self):

   379

        if os.name == 'nt':

   380

            # on windows, desktop shortcut launches Beremiz.py

   381

            # with working dir set to mingw/bin.

   382

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

   383

            # commands invoked by build process by default are

   384

            # found here.

   385

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

   386

   387

   388

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

   389

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

   390

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

   391

        self.__init_execute_path()

   392

   393

        IDEFrame.__init__(self, parent, debug)

   394

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

   395

   396

        self.local_runtime = None

   397

        self.runtime_port = None

   398

        self.local_runtime_tmpdir = None

   399

   400

        self.LastPanelSelected = None

   401

   402

        # Define Tree item icon list

   403

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

   404

        self.LocationImageDict = {}

   405

   406

        # Icons for location items

   407

        for imgname, itemtype in [

   408

            ("CONFIGURATION", LOCATION_CONFNODE),

   409

            ("RESOURCE",      LOCATION_MODULE),

   410

            ("PROGRAM",       LOCATION_GROUP),

   411

            ("VAR_INPUT",     LOCATION_VAR_INPUT),

   412

            ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   413

            ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   414

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

   415

   416

        # Icons for other items

   417

        for imgname, itemtype in [

   418

            ("Extension", ITEM_CONFNODE)]:

   419

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

   420

   421

        if projectOpen is not None:

   422

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   423

   424

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

   425

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

   426

            self.Controler = self.CTR

   427

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

   428

            if not result:

   429

                self.LibraryPanel.SetController(self.Controler)

   430

                self.ProjectTree.Enable(True)

   431

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   432

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

   433

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   434

            else:

   435

                self.ResetView()

   436

                self.ShowErrorMessage(result)

   437

        else:

   438

            self.CTR = ctr

   439

            self.Controler = ctr

   440

            if ctr is not None:

   441

                self.LibraryPanel.SetController(self.Controler)

   442

                self.ProjectTree.Enable(True)

   443

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   444

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   445

        if self.EnableDebug:

   446

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   447

   448

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

   449

   450

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

   451

        self.RefreshAll()

   452

        self.LogConsole.SetFocus()

   453

   454

    def RefreshTitle(self):

   455

        name = _("Beremiz")

   456

        if self.CTR is not None:

   457

            projectname = self.CTR.GetProjectName()

   458

            if self.CTR.ProjectTestModified():

   459

                projectname = "~%s~" % projectname

   460

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

   461

        else:

   462

            self.SetTitle(name)

   463

   464

    def StartLocalRuntime(self, taskbaricon = True):

   465

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

   466

            # create temporary directory for runtime working directory

   467

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   468

            # choose an arbitrary random port for runtime

   469

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

   470

            # launch local runtime

   471

            self.local_runtime = ProcessLogger(self.Log,

   472

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

   473

                    sys.executable,

   474

                    Bpath("Beremiz_service.py"),

   475

                    self.runtime_port,

   476

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

   477

                    self.local_runtime_tmpdir),

   478

                no_gui=False,

   479

                timeout=500, keyword = self.local_runtime_tmpdir,

   480

                cwd = self.local_runtime_tmpdir)

   481

            self.local_runtime.spin()

   482

        return self.runtime_port

   483

   484

    def KillLocalRuntime(self):

   485

        if self.local_runtime is not None:

   486

            # shutdown local runtime

   487

            self.local_runtime.kill(gently=False)

   488

            # clear temp dir

   489

            shutil.rmtree(self.local_runtime_tmpdir)

   490

   491

            self.local_runtime = None

   492

   493

    def OnOpenWidgetInspector(self, evt):

   494

        # Activate the widget inspection tool

   495

        from wx.lib.inspection import InspectionTool

   496

        if not InspectionTool().initialized:

   497

            InspectionTool().Init()

   498

   499

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

   500

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

   501

        wnd = wx.FindWindowAtPointer()

   502

        if not wnd:

   503

            wnd = self

   504

        InspectionTool().Show(wnd, True)

   505

   506

    def OnLogConsoleFocusChanged(self, event):

   507

        self.RefreshEditMenu()

   508

        event.Skip()

   509

   510

    def OnLogConsoleUpdateUI(self, event):

   511

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

   512

        event.Skip()

   513

   514

    def OnLogConsoleMarginClick(self, event):

   515

        line_idx = self.LogConsole.LineFromPosition(event.GetPosition())

   516

        wx.CallAfter(self.SearchLineForError, self.LogConsole.GetLine(line_idx))

   517

        event.Skip()

   518

   519

    def OnLogConsoleModified(self, event):

   520

        line_idx = self.LogConsole.LineFromPosition(event.GetPosition())

   521

        line = self.LogConsole.GetLine(line_idx)

   522

        if line:

   523

            result = MATIEC_ERROR_MODEL.match(line)

   524

            if result is not None:

   525

                self.LogConsole.MarkerAdd(line_idx, 0)

   526

        event.Skip()

   527

   528

    def SearchLineForError(self, line):