1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

# Copyright (C) 2016: Andrey Skvortsov <andrej.skvortzov@gmail.com>

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

# This program is free software; you can redistribute it and/or

    13

# modify it under the terms of the GNU General Public License

    14

# as published by the Free Software Foundation; either version 2

    15

# of the License, or (at your option) any later version.

    16

#

    17

# This program is distributed in the hope that it will be useful,

    18

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

# You should have received a copy of the GNU General Public License

    23

# along with this program; if not, write to the Free Software

    24

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    25

    26

    27

from __future__ import absolute_import

    28

from __future__ import print_function

    29

import os

    30

import sys

    31

import tempfile

    32

import shutil

    33

import random

    34

import time

    35

from time import time as gettime

    36

from threading import Lock, Timer, currentThread

    37

    38

from six.moves import cPickle, xrange

    39

import wx.lib.buttons

    40

import wx.lib.statbmp

    41

import wx.stc

    42

    43

    44

import version

    45

from editors.EditorPanel import EditorPanel

    46

from editors.Viewer import Viewer

    47

from editors.TextViewer import TextViewer

    48

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    49

from editors.DataTypeEditor import DataTypeEditor

    50

from util import paths as paths

    51

from util.MiniTextControler import MiniTextControler

    52

from util.ProcessLogger import ProcessLogger

    53

from util.BitmapLibrary import GetBitmap

    54

from controls.LogViewer import LogViewer

    55

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

    56

from controls import EnhancedStatusBar as esb

    57

from dialogs.AboutDialog import ShowAboutDialog

    58

    59

from plcopen.types_enums import \

    60

    ComputeConfigurationName, \

    61

    LOCATION_CONFNODE, \

    62

    LOCATION_MODULE, \

    63

    LOCATION_GROUP, \

    64

    LOCATION_VAR_INPUT, \

    65

    LOCATION_VAR_OUTPUT, \

    66

    LOCATION_VAR_MEMORY, \

    67

    ITEM_PROJECT, \

    68

    ITEM_RESOURCE, \

    69

    ITEM_CONFNODE

    70

    71

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL

    72

    73

from IDEFrame import \

    74

    TITLE,\

    75

    EDITORTOOLBAR,\

    76

    FILEMENU,\

    77

    EDITMENU,\

    78

    DISPLAYMENU,\

    79

    PROJECTTREE,\

    80

    POUINSTANCEVARIABLESPANEL,\

    81

    LIBRARYTREE,\

    82

    PAGETITLES,\

    83

    IDEFrame, \

    84

    AppendMenu,\

    85

    EncodeFileSystemPath, \

    86

    DecodeFileSystemPath

    87

    88

    89

beremiz_dir = paths.AbsDir(__file__)

    90

    91

    92

def Bpath(*args):

    93

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

    94

    95

    96

MAX_RECENT_PROJECTS = 9

    97

    98

    99

if wx.Platform == '__WXMSW__':

   100

    faces = {

   101

        'mono': 'Courier New',

   102

        'size': 8,

   103

    }

   104

else:

   105

    faces = {

   106

        'mono': 'FreeMono',

   107

        'size': 10,

   108

    }

   109

   110

   111

MainThread = currentThread().ident

   112

REFRESH_PERIOD = 0.1

   113

   114

   115

class LogPseudoFile(object):

   116

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

   117

    def __init__(self, output, risecall):

   118

        self.red_white = 1

   119

        self.red_yellow = 2

   120

        self.black_white = wx.stc.STC_STYLE_DEFAULT

   121

        self.output = output

   122

        self.risecall = risecall

   123

        # to prevent rapid fire on rising log panel

   124

        self.rising_timer = 0

   125

        self.StackLock = Lock()

   126

        self.YieldLock = Lock()

   127

        self.RefreshLock = Lock()

   128

        self.TimerAccessLock = Lock()

   129

        self.stack = []

   130

        self.LastRefreshTime = gettime()

   131

        self.LastRefreshTimer = None

   133

   134

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

   135

        self.StackLock.acquire()

   136

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

   137

        self.StackLock.release()

   138

        current_time = gettime()

   139

        with self.TimerAccessLock:

   140

            if self.LastRefreshTimer is not None:

   141

                self.LastRefreshTimer.cancel()

   142

                self.LastRefreshTimer = None

   143

        elapsed = current_time - self.LastRefreshTime

   144

        if elapsed > REFRESH_PERIOD:

   145

            self._should_write()

   146

        else:

   147

            with self.TimerAccessLock:

   148

                if self.LastRefreshTimer is None:

   149

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

   150

                    self.LastRefreshTimer.start()

   151

   152

    def _timer_expired(self):

   153

        self._should_write()

   154

        with self.TimerAccessLock:

   155

            self.LastRefreshTimer = None

   156

   157

    def _should_write(self):

   158

        if MainThread == currentThread().ident:

   159

            app = wx.GetApp()

   160

            if app is not None:

   161

                self._write()

   162

                if self.YieldLock.acquire(0):

   163

                    app.Yield()

   164

                    self.YieldLock.release()

   165

        else:

   166

            with self.RefreshLock:

   167

                if not self.refreshPending:

   168

                    self.refreshPending = True

   169

                    wx.CallAfter(self._write)

   170

   171

    def _write(self):

   172

        if self.output:

   173

            with self.RefreshLock:

   174

                self.output.Freeze()

   175

                self.output.AnnotationClearAll()

   176

                self.StackLock.acquire()

   177

                for s, style in self.stack:

   178

                    if style is None:

   179

                        style = self.black_white

   180

                    if style != self.black_white:

   181

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

   182

   183

                    # Temporary deactivate read only mode on StyledTextCtrl for

   184

                    # adding text. It seems that text modifications, even

   185

                    # programmatically, are disabled in StyledTextCtrl when read

   186

                    # only is active

   187

                    start_pos = self.output.GetLength()

   188

                    self.output.SetReadOnly(False)

   189

                    self.output.AppendText(s)

   190

                    self.output.SetReadOnly(True)

   191

                    text_len = self.output.GetLength() - start_pos

   192

   193

                    if style != self.black_white:

   194

                        self.output.SetStyling(text_len, style)

   195

                self.stack = []

   196

                self.StackLock.release()

   197

                self.output.Thaw()

   198

                self.LastRefreshTime = gettime()

   199

                newtime = time.time()

   200

                if newtime - self.rising_timer > 1:

   201

                    self.risecall(self.output)

   202

                self.rising_timer = newtime

   203

                self.refreshPending = False

   204

   205

   206

    def write_warning(self, s):

   207

        self.write(s, self.red_white)

   208

   209

    def write_error(self, s):

   210

        self.write(s, self.red_yellow)

   211

   212

    def flush(self):

   213

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   214

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

   215

        # disabled in StyledTextCtrl when read only is active

   216

        self.output.SetReadOnly(False)

   217

        self.output.SetText("")

   218

        self.output.SetReadOnly(True)

   219

   220

    def isatty(self):

   221

        return False

   222

   233

   234

ID_FILEMENURECENTPROJECTS = wx.NewId()

   235

   236

   237

class Beremiz(IDEFrame):

   238

   239

    def _init_utils(self):

   240

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

   241

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

   242

   243

        IDEFrame._init_utils(self)

   244

   245

    def _init_coll_FileMenu_Items(self, parent):

   246

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

   247

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

   248

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

   249

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

   250

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

   251

        parent.AppendSeparator()

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

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

   260

        parent.AppendSeparator()

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

        parent.AppendSeparator()

   268

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

   269

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

   270

   271

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

   272

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

   273

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

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

   280

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

   281

   282

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

   283

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

   284

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

   285

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

   286

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

   287

   288

    def _RecursiveAddMenuItems(self, menu, items):

   289

        for name, text, helpstr, children in items:

   290

            if len(children) > 0:

   291

                new_menu = wx.Menu(title='')

   292

                menu.AppendMenu(wx.ID_ANY, text, new_menu)

   293

                self._RecursiveAddMenuItems(new_menu, children)

   294

            else:

   295

                item = menu.Append(wx.ID_ANY, text, helpstr)

   296

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

   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

        item = parent.Append(wx.ID_ANY, _(u'Community support'), '')

   310

        self.Bind(wx.EVT_MENU, handler, item)

   311

   312

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

   313

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

   314

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

   315

   316

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   317

        parent.SetFieldsCount(3)

   318

   319

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

   320

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

   321

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

   322

   323

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

   324

   325

    def _init_ctrls(self, prnt):

   326

        IDEFrame._init_ctrls(self, prnt)

   327

   328

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   329

   330

        inspectorID = wx.NewId()

   331

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

   332

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

   333

   334

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

   335

                                 ("Run",      wx.WXK_F5),

   336

                                 ("Transfer", wx.WXK_F6),

   337

                                 ("Connect",  wx.WXK_F7),

   338

                                 ("Build",    wx.WXK_F11)]:

   339

            def OnMethodGen(obj, meth):

   340

                def OnMethod(evt):

   341

                    if obj.CTR is not None:

   342

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

   343

                    wx.CallAfter(self.RefreshStatusToolBar)

   344

                return OnMethod

   345

            newid = wx.NewId()

   346

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

   347

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

   348

   349

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   350

   351

        self.LogConsole = CustomStyledTextCtrl(

   352

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

   353

            size=wx.Size(0, 0))

   354

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

   355

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

   356

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

   357

        self.LogConsole.SetReadOnly(True)

   358

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

   359

   360

        # Define Log Console styles

   361

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

   362

        self.LogConsole.StyleClearAll()

   363

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

   364

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

   365

   366

        # Define Log Console markers

   367

        self.LogConsole.SetMarginSensitive(1, True)

   368

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

   369

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

   370

   371

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

   372

   373

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

   374

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

   375

   376

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

   377

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

   378

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

   379

   380

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

   381

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

   382

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

   383

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

   384

   385

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

   386

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

   387

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

   388

        StatusToolBar.Realize()

   389

        self.Panes["StatusToolBar"] = StatusToolBar

   390

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

   391

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

   392

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

   393

                                LeftDockable(False).RightDockable(False))

   394

   395

        self.AUIManager.Update()

   396

   397

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

   398

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   399

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

   400

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

   401

        self.ProgressStatusBar.Hide()

   402

        self.SetStatusBar(self.ConnectionStatusBar)

   403

   404

    def __init_execute_path(self):

   405

        if os.name == 'nt':

   406

            # on windows, desktop shortcut launches Beremiz.py

   407

            # with working dir set to mingw/bin.

   408

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

   409

            # commands invoked by build process by default are

   410

            # found here.

   411

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

   412

   413

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

   414

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

   415

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

   416

        self.__init_execute_path()

   417

   418

        IDEFrame.__init__(self, parent, debug)

   419

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

   420

   421

        self.local_runtime = None

   422

        self.runtime_port = None

   423

        self.local_runtime_tmpdir = None

   424

   425

        self.LastPanelSelected = None

   426

   427

        # Define Tree item icon list

   428

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

   429

        self.LocationImageDict = {}

   430

   431

        # Icons for location items

   432

        for imgname, itemtype in [

   433

                ("CONFIGURATION", LOCATION_CONFNODE),

   434

                ("RESOURCE",      LOCATION_MODULE),

   435

                ("PROGRAM",       LOCATION_GROUP),

   436

                ("VAR_INPUT",     LOCATION_VAR_INPUT),

   437

                ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   438

                ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   439

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

   440

   441

        # Icons for other items

   442

        for imgname, itemtype in [

   443

                ("Extension", ITEM_CONFNODE)]:

   444

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

   445

   446

        if projectOpen is not None:

   447

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   448

   449

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

   450

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

   451

            self.Controler = self.CTR

   452

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

   453

            if not result:

   454

                self.LibraryPanel.SetController(self.Controler)

   455

                self.ProjectTree.Enable(True)

   456

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   457

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

   458

                self.RefreshAfterLoad()

   459

            else:

   460

                self.ResetView()

   461

                self.ShowErrorMessage(result)

   462

        else:

   463

            self.CTR = ctr

   464

            self.Controler = ctr

   465

            if ctr is not None:

   466

                ctr.SetAppFrame(self, self.Log)

   467

                self.LibraryPanel.SetController(self.Controler)

   468

                self.ProjectTree.Enable(True)

   469

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   470

                self.RefreshAfterLoad()

   471

        if self.EnableDebug:

   472

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   473

   474

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

   475

   476

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

   477

        self.RefreshAll()

   478

        self.LogConsole.SetFocus()

   479

   480

    def RefreshTitle(self):

   481

        name = _("Beremiz")

   482

        if self.CTR is not None:

   483

            projectname = self.CTR.GetProjectName()

   484

            if self.CTR.ProjectTestModified():

   485

                projectname = "~%s~" % projectname

   486

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

   487

        else:

   488

            self.SetTitle(name)

   489

   490

    def StartLocalRuntime(self, taskbaricon=True):

   491

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

   492

            # create temporary directory for runtime working directory

   493

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   494

            # choose an arbitrary random port for runtime

   495

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

   496

            # launch local runtime

   497

            self.local_runtime = ProcessLogger(

   498

                self.Log,

   499

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

   500

                    sys.executable,

   501

                    Bpath("Beremiz_service.py"),

   502

                    self.runtime_port,

   503

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

   504

                    self.local_runtime_tmpdir),

   505

                no_gui=False,

   506

                timeout=500, keyword=self.local_runtime_tmpdir,