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

#

     9

# See COPYING file for copyrights details.

    10

#

    11

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

    12

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

    13

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

    14

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

    15

#

    16

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

    17

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

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

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

    22

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

    23

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

    24

    25

    26

from __future__ import absolute_import

    27

from __future__ import division

    28

import re

    29

from builtins import str as text

    30

    31

import wx

    32

import wx.grid

    33

import wx.stc as stc

    34

import wx.lib.buttons

    35

from six.moves import xrange

    36

    37

    38

from plcopen.plcopen import TestTextElement

    39

from plcopen.structures import TestIdentifier, IEC_KEYWORDS, DefaultType

    40

from controls import CustomGrid, CustomTable

    41

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl, faces, GetCursorPos, NAVIGATION_KEYS

    42

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    43

from util.BitmapLibrary import GetBitmap

    44

from util.TranslationCatalogs import NoTranslate

    45

from graphics.GraphicCommons import ERROR_HIGHLIGHT, SEARCH_RESULT_HIGHLIGHT, REFRESH_HIGHLIGHT_PERIOD

    46

    47

    48

[STC_CODE_ERROR, STC_CODE_SEARCH_RESULT,

    49

 STC_CODE_SECTION] = range(15, 18)

    50

    51

HIGHLIGHT_TYPES = {

    52

    ERROR_HIGHLIGHT: STC_CODE_ERROR,

    53

    SEARCH_RESULT_HIGHLIGHT: STC_CODE_SEARCH_RESULT,

    54

}

    55

    56

EDGE_COLUMN = 80

    57

    58

    59

def GetSectionsText(controler, sections_headers):

    60

    parts = controler.GetTextParts()

    61

    text = ""

    62

    for section in controler.SECTIONS_NAMES:

    63

        text += sections_headers(section)

    64

        if parts[section] == "":

    65

            text += "\n"

    66

        else:

    67

            if not parts[section].startswith("\n"):

    68

                text += "\n"

    69

            text += parts[section]

    70

            if not parts[section].endswith("\n"):

    71

                text += "\n"

    72

    return text

    73

    74

    75

class CodeEditor(CustomStyledTextCtrl):

    76

    77

    KEYWORDS = []

    78

    COMMENT_HEADER = ""

    79

    80

    def __init__(self, parent, window, controler):

    81

        CustomStyledTextCtrl.__init__(self, parent, -1, wx.DefaultPosition,

    82

                                      wx.Size(-1, 300), 0)

    83

    84

        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)

    85

        self.SetMarginWidth(1, 25)

    86

    87

        self.SetProperty("fold", "1")

    88

        self.SetProperty("tab.timmy.whinge.level", "1")

    89

        self.SetMargins(0, 0)

    90

    91

        self.SetViewWhiteSpace(False)

    92

    93

        self.SetEdgeMode(stc.STC_EDGE_BACKGROUND)

    94

        self.SetEdgeColumn(EDGE_COLUMN)

    95

    96

        # Setup a margin to hold fold markers

    97

        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)

    98

        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)

    99

        self.SetMarginSensitive(2, True)

   100

        self.SetMarginWidth(2, 12)

   101

   102

        # Like a flattened tree control using square headers

   103

        self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_BOXMINUS,          "white", "#808080")

   104

        self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_BOXPLUS,           "white", "#808080")

   105

        self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_VLINE,             "white", "#808080")

   106

        self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_LCORNER,           "white", "#808080")

   107

        self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_BOXPLUSCONNECTED,  "white", "#808080")

   108

        self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_BOXMINUSCONNECTED, "white", "#808080")

   109

        self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_TCORNER,           "white", "#808080")

   110

   111

        self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdateUI)

   112

        self.Bind(stc.EVT_STC_MARGINCLICK, self.OnMarginClick)

   113

        self.Bind(wx.EVT_KEY_DOWN, self.OnKeyPressed)

   114

   115

        # Make some styles,  The lexer defines what each style is used for, we

   116

        # just have to define what each style looks like.  This set is adapted from

   117

        # Scintilla sample property files.

   118

   119

        # Global default styles for all languages

   120

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

   121

        self.StyleClearAll()  # Reset all to be like the default

   122

   123

        # Global default styles for all languages

   124

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

   125

        self.StyleSetSpec(stc.STC_STYLE_LINENUMBER,  "back:#C0C0C0,face:%(helv)s,size:%(size)d" % faces)

   126

        self.StyleSetSpec(stc.STC_STYLE_CONTROLCHAR, "face:%(mono)s" % faces)

   127

        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,  "fore:#FFFFFF,back:#0000FF,bold")

   128

        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,    "fore:#000000,back:#FF0000,bold")

   129

   130

        # Highlighting styles

   131

        self.StyleSetSpec(STC_CODE_ERROR, 'fore:#FF0000,back:#FFFF00,size:%(size)d' % faces)

   132

        self.StyleSetSpec(STC_CODE_SEARCH_RESULT, 'fore:#FFFFFF,back:#FFA500,size:%(size)d' % faces)

   133

   134

        # Section style

   135

        self.StyleSetSpec(STC_CODE_SECTION, 'fore:#808080,size:%(size)d')

   136

        self.StyleSetChangeable(STC_CODE_SECTION, False)

   137

   138

        # Indentation size

   139

        self.SetTabWidth(4)

   140

        self.SetUseTabs(0)

   141

   142

        self.SetCodeLexer()

   143

        self.SetKeyWords(0, " ".join(self.KEYWORDS))

   144

   145

        self.Controler = controler

   146

        self.ParentWindow = window

   147

   148

        self.DisableEvents = True

   149

        self.CurrentAction = None

   150

   151

        self.ResetSearchResults()

   152

   153

        self.RefreshHighlightsTimer = wx.Timer(self, -1)

   154

        self.Bind(wx.EVT_TIMER, self.OnRefreshHighlightsTimer, self.RefreshHighlightsTimer)

   155

   156

        self.SectionsComments = {}

   157

        for section in self.Controler.SECTIONS_NAMES:

   158

            section_comment = " %s section " % (section)

   159

            len_headers = EDGE_COLUMN - len(section_comment)

   160

            section_comment = \

   161

                self.COMMENT_HEADER * (len_headers // 2) + \

   162

                section_comment + \

   163

                self.COMMENT_HEADER * (len_headers - len_headers // 2)

   164

   165

            self.SectionsComments[section] = {

   166

                "comment": section_comment,

   167

            }

   168

   169

        for i, section in enumerate(self.Controler.SECTIONS_NAMES):

   170

            section_infos = self.SectionsComments[section]

   171

            if i + 1 < len(self.Controler.SECTIONS_NAMES):

   172

                section_end = self.SectionsComments[

   173

                    self.Controler.SECTIONS_NAMES[i + 1]]["comment"]

   174

            else:

   175

                section_end = "$"

   176

            section_infos["pattern"] = re.compile(

   177

                section_infos["comment"] + "(.*)" +

   178

                section_end, re.DOTALL)

   179

   180

        self.SetModEventMask(wx.stc.STC_MOD_BEFOREINSERT | wx.stc.STC_MOD_BEFOREDELETE)

   181

   182

        self.Bind(wx.stc.EVT_STC_DO_DROP, self.OnDoDrop)

   183

        self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)

   184

        self.Bind(wx.stc.EVT_STC_MODIFIED, self.OnModification)

   185

   186

    def SetCodeLexer(self):

   187

        pass

   188

   189

    def ResetSearchResults(self):

   190

        self.Highlights = []

   191

        self.SearchParams = None

   192

        self.SearchResults = None

   193

        self.CurrentFindHighlight = None

   194

   195

    def OnModification(self, event):

   196

        if not self.DisableEvents:

   197

            mod_type = event.GetModificationType()

   198

            if not (mod_type & wx.stc.STC_PERFORMED_UNDO or mod_type & wx.stc.STC_PERFORMED_REDO):

   199

                if mod_type & wx.stc.STC_MOD_BEFOREINSERT:

   200

                    if self.CurrentAction is None:

   201

                        self.StartBuffering()

   202

                    elif self.CurrentAction[0] != "Add" or self.CurrentAction[1] != event.GetPosition() - 1:

   203

                        self.Controler.EndBuffering()

   204

                        self.StartBuffering()

   205

                    self.CurrentAction = ("Add", event.GetPosition())

   206

                    wx.CallAfter(self.RefreshModel)

   207

                elif mod_type & wx.stc.STC_MOD_BEFOREDELETE:

   208

                    if self.CurrentAction is None:

   209

                        self.StartBuffering()

   210

                    elif self.CurrentAction[0] != "Delete" or self.CurrentAction[1] != event.GetPosition() + 1:

   211

                        self.Controler.EndBuffering()

   212

                        self.StartBuffering()

   213

                    self.CurrentAction = ("Delete", event.GetPosition())

   214

                    wx.CallAfter(self.RefreshModel)

   215

        wx.CallAfter(self.RefreshSectionStyling)

   216

        event.Skip()

   217

   218

    def OnDoDrop(self, event):

   219

        try:

   220

            values = eval(event.GetDragText())

   221

        except Exception:

   222

            values = event.GetDragText()

   223

        if isinstance(values, tuple):

   224

            if values[3] == self.Controler.GetCurrentLocation():

   225

                self.ResetBuffer()

   226

                event.SetDragText(values[0])

   227

                wx.CallAfter(self.RefreshModel)

   228

            else:

   229

                event.SetDragText("")

   230

        else:

   231

            self.ResetBuffer()

   232

            wx.CallAfter(self.RefreshModel)

   233

        event.Skip()

   234

   235

    # Buffer the last model state

   236

    def RefreshBuffer(self):

   237

        self.Controler.BufferCodeFile()

   238

        if self.ParentWindow is not None:

   239

            self.ParentWindow.RefreshTitle()

   240

            self.ParentWindow.RefreshFileMenu()

   241

            self.ParentWindow.RefreshEditMenu()

   242

            self.ParentWindow.RefreshPageTitles()

   243

   244

    def StartBuffering(self):

   245

        self.Controler.StartBuffering()

   246

        if self.ParentWindow is not None:

   247

            self.ParentWindow.RefreshTitle()

   248

            self.ParentWindow.RefreshFileMenu()

   249

            self.ParentWindow.RefreshEditMenu()

   250

            self.ParentWindow.RefreshPageTitles()

   251

   252

    def ResetBuffer(self):

   253

        if self.CurrentAction is not None:

   254

            self.Controler.EndBuffering()

   255

            self.CurrentAction = None

   256

   257

    def GetCodeText(self):

   258

        return GetSectionsText(

   259

            self.Controler,

   260

            lambda section: self.SectionsComments[section]["comment"])

   261

   262

    def RefreshView(self, scroll_to_highlight=False):

   263

        self.ResetBuffer()

   264

        self.DisableEvents = True

   265

        old_cursor_pos = self.GetCurrentPos()

   266

        line = self.GetFirstVisibleLine()

   267

        column = self.GetXOffset()

   268

        old_text = self.GetText()

   269

        new_text = self.GetCodeText()

   270

        if old_text != new_text:

   271

            self.SetText(new_text)

   272

            new_cursor_pos = GetCursorPos(old_text, new_text)

   273

            self.LineScroll(column, line)

   274

            if new_cursor_pos is not None:

   275

                self.GotoPos(new_cursor_pos)

   276

            else:

   277

                self.GotoPos(old_cursor_pos)

   278

            self.EmptyUndoBuffer()

   279

        self.DisableEvents = False

   280

   281

        self.RefreshSectionStyling()

   282

   283

        self.ShowHighlights()

   284

   285

    def RefreshSectionStyling(self):

   286

        self.Colourise(0, -1)

   287

   288

        for line in xrange(self.GetLineCount()):

   289

            self.SetLineState(line, 0)

   290

   291

        doc_end_pos = self.GetLength()

   292

        for section in self.Controler.SECTIONS_NAMES:

   293

            section_comments = self.SectionsComments[section]

   294

            start_pos, end_pos = self.FindText(0, doc_end_pos, section_comments["comment"])

   295

            self.StartStyling(start_pos)

   296

            self.SetStyling(end_pos - start_pos, STC_CODE_SECTION)

   297

            self.SetLineState(self.LineFromPosition(start_pos), 1)

   298

   299

        self.StartStyling(end_pos)

   300

        self.SetStyling(doc_end_pos - end_pos, stc.STC_STYLE_DEFAULT)

   301

   302

    def DoGetBestSize(self):

   303

        return self.ParentWindow.GetBestSize()

   304

   305

    def RefreshModel(self):

   306

        text = self.GetText()

   307

        parts = {}

   308

        for section in self.Controler.SECTIONS_NAMES:

   309

            section_comments = self.SectionsComments[section]

   310

            result = section_comments["pattern"].search(text)

   311

            if result is not None:

   312

                parts[section] = result.group(1)

   313

            else:

   314

                parts[section] = ""

   315

        self.Controler.SetTextParts(parts)

   316

        self.ResetSearchResults()

   317

   318

    def OnKeyPressed(self, event):

   319

        if self.CallTipActive():

   320

            self.CallTipCancel()

   321

        key = event.GetKeyCode()

   322

        current_pos = self.GetCurrentPos()

   323

        selected = self.GetSelection()

   324

        text_selected = selected[0] != selected[1]

   325

   326

        # Test if caret is before Windows like new line

   327

        text = self.GetText()

   328

        if current_pos < len(text) and ord(text[current_pos]) == 13:

   329

            newline_size = 2

   330

        else:

   331

            newline_size = 1

   332

   333

        # Disable to type any character in section header lines

   334

        if self.GetLineState(self.LineFromPosition(current_pos)) and \

   335

           not text_selected and \

   336

           key not in NAVIGATION_KEYS + [wx.WXK_RETURN, wx.WXK_NUMPAD_ENTER]:

   337

            return

   338

   339

        # Disable to delete line between code and header lines

   340

        elif (self.GetCurLine()[0].strip() != "" and not text_selected and

   341

              (key == wx.WXK_BACK and

   342

               self.GetLineState(self.LineFromPosition(max(0, current_pos - 1))) or

   343

               key in [wx.WXK_DELETE, wx.WXK_NUMPAD_DELETE] and

   344

               self.GetLineState(self.LineFromPosition(min(len(text), current_pos + newline_size))))):

   345

            return

   346

   347

        elif key == 32 and event.ControlDown():

   348

            # Tips

   349

            if event.ShiftDown():

   350

                pass

   351

            # Code completion

   352

            else:

   353

                self.AutoCompSetIgnoreCase(False)  # so this needs to match

   354

   355

                keywords = self.KEYWORDS + [var["Name"]

   356

                                            for var in self.Controler.GetVariables()]

   357

                keywords.sort()

   358

                self.AutoCompShow(0, " ".join(keywords))

   359

        else:

   360

            event.Skip()

   361

   362

    def OnKillFocus(self, event):

   363

        self.AutoCompCancel()

   364

        event.Skip()

   365

   366

    def OnUpdateUI(self, event):

   367

        # check for matching braces

   368

        braceAtCaret = -1

   369

        braceOpposite = -1

   370

        charBefore = None

   371

        caretPos = self.GetCurrentPos()

   372

   373

        if caretPos > 0:

   374

            charBefore = self.GetCharAt(caretPos - 1)

   375

            styleBefore = self.GetStyleAt(caretPos - 1)

   376

   377

        # check before

   378

        if charBefore and chr(charBefore) in "[]{}()" and styleBefore == stc.STC_P_OPERATOR:

   379

            braceAtCaret = caretPos - 1

   380

   381

        # check after

   382

        if braceAtCaret < 0:

   383

            charAfter = self.GetCharAt(caretPos)

   384

            styleAfter = self.GetStyleAt(caretPos)

   385

   386

            if charAfter and chr(charAfter) in "[]{}()" and styleAfter == stc.STC_P_OPERATOR:

   387

                braceAtCaret = caretPos

   388

   389

        if braceAtCaret >= 0:

   390

            braceOpposite = self.BraceMatch(braceAtCaret)

   391

   392

        if braceAtCaret != -1 and braceOpposite == -1:

   393

            self.BraceBadLight(braceAtCaret)

   394

        else:

   395

            self.BraceHighlight(braceAtCaret, braceOpposite)

   396

   397

        selected_text = self.GetSelectedText()

   398

        if selected_text:

   399

            self.ParentWindow.SetCopyBuffer(selected_text, True)

   400

   401

    def OnMarginClick(self, event):

   402

        # fold and unfold as needed

   403

        if event.GetMargin() == 2:

   404

            if event.GetShift() and event.GetControl():

   405

                self.FoldAll()

   406

            else:

   407

                lineClicked = self.LineFromPosition(event.GetPosition())

   408

   409

                if self.GetFoldLevel(lineClicked) & stc.STC_FOLDLEVELHEADERFLAG:

   410

                    if event.GetShift():

   411

                        self.SetFoldExpanded(lineClicked, True)

   412

                        self.Expand(lineClicked, True, True, 1)

   413

                    elif event.GetControl():

   414

                        if self.GetFoldExpanded(lineClicked):

   415

                            self.SetFoldExpanded(lineClicked, False)

   416

                            self.Expand(lineClicked, False, True, 0)

   417

                        else:

   418

                            self.SetFoldExpanded(lineClicked, True)

   419

                            self.Expand(lineClicked, True, True, 100)

   420

                    else:

   421

                        self.ToggleFold(lineClicked)

   422

        event.Skip()

   423

   424

    def FoldAll(self):

   425

        lineCount = self.GetLineCount()

   426

        expanding = True

   427

   428

        # find out if we are folding or unfolding

   429

        for lineNum in range(lineCount):

   430

            if self.GetFoldLevel(lineNum) & stc.STC_FOLDLEVELHEADERFLAG:

   431

                expanding = not self.GetFoldExpanded(lineNum)

   432

                break

   433

   434

        lineNum = 0

   435

   436

        while lineNum < lineCount:

   437

            level = self.GetFoldLevel(lineNum)

   438

            if level & stc.STC_FOLDLEVELHEADERFLAG and \

   439

               (level & stc.STC_FOLDLEVELNUMBERMASK) == stc.STC_FOLDLEVELBASE:

   440

   441

                if expanding:

   442

                    self.SetFoldExpanded(lineNum, True)

   443

                    lineNum = self.Expand(lineNum, True)

   444

                    lineNum = lineNum - 1

   445

                else:

   446

                    lastChild = self.GetLastChild(lineNum, -1)

   447

                    self.SetFoldExpanded(lineNum, False)

   448

   449

                    if lastChild > lineNum:

   450

                        self.HideLines(lineNum+1, lastChild)

   451

   452

            lineNum = lineNum + 1

   453

   454

    def Expand(self, line, doExpand, force=False, visLevels=0, level=-1):

   455

        lastChild = self.GetLastChild(line, level)

   456

        line = line + 1

   457

   458

        while line <= lastChild:

   459

            if force:

   460

                if visLevels > 0:

   461

                    self.ShowLines(line, line)

   462

                else:

   463

                    self.HideLines(line, line)

   464

            else:

   465

                if doExpand:

   466

                    self.ShowLines(line, line)

   467

   468

            if level == -1:

   469

                level = self.GetFoldLevel(line)

   470

   471

            if level & stc.STC_FOLDLEVELHEADERFLAG:

   472

                if force:

   473

                    if visLevels > 1:

   474

                        self.SetFoldExpanded(line, True)

   475

                    else:

   476

                        self.SetFoldExpanded(line, False)

   477

   478

                    line = self.Expand(line, doExpand, force, visLevels-1)

   479

   480

                else:

   481

                    if doExpand and self.GetFoldExpanded(line):

   482

                        line = self.Expand(line, True, force, visLevels-1)

   483

                    else:

   484

                        line = self.Expand(line, False, force, visLevels-1)

   485

            else:

   486

                line = line + 1

   487

   488

        return line

   489

   490

    def Cut(self):

   491

        self.ResetBuffer()

   492

        self.DisableEvents = True

   493

        self.CmdKeyExecute(wx.stc.STC_CMD_CUT)

   494

        self.DisableEvents = False

   495

        self.RefreshModel()

   496

        self.RefreshBuffer()