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

import re

    28

    29

import wx

    30

import wx.grid

    31

import wx.stc as stc

    32

import wx.lib.buttons

    33

    34

from plcopen.plcopen import TestTextElement

    35

from plcopen.structures import TestIdentifier, IEC_KEYWORDS, DefaultType

    36

from controls import CustomGrid, CustomTable

    37

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

    38

from controls.VariablePanel import VARIABLE_NAME_SUFFIX_MODEL

    39

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    40

from util.BitmapLibrary import GetBitmap

    41

from util.TranslationCatalogs import NoTranslate

    42

from graphics.GraphicCommons import ERROR_HIGHLIGHT, SEARCH_RESULT_HIGHLIGHT, REFRESH_HIGHLIGHT_PERIOD

    43

    44

    45

[STC_CODE_ERROR, STC_CODE_SEARCH_RESULT,

    46

 STC_CODE_SECTION] = range(15, 18)

    47

    48

HIGHLIGHT_TYPES = {

    49

    ERROR_HIGHLIGHT: STC_CODE_ERROR,

    50

    SEARCH_RESULT_HIGHLIGHT: STC_CODE_SEARCH_RESULT,

    51

}

    52

    53

EDGE_COLUMN = 80

    54

    55

    56

class CodeEditor(CustomStyledTextCtrl):

    57

    58

    KEYWORDS = []

    59

    COMMENT_HEADER = ""

    60

    61

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

    62

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

    63

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

    64

    65

        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)

    66

        self.SetMarginWidth(1, 25)

    67

    68

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

    69

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

    70

        self.SetMargins(0, 0)

    71

    72

        self.SetViewWhiteSpace(False)

    73

    74

        self.SetEdgeMode(stc.STC_EDGE_BACKGROUND)

    75

        self.SetEdgeColumn(EDGE_COLUMN)

    76

    77

        # Setup a margin to hold fold markers

    78

        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)

    79

        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)

    80

        self.SetMarginSensitive(2, True)

    81

        self.SetMarginWidth(2, 12)

    82

    83

        # Like a flattened tree control using square headers

    84

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

    85

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

    86

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

    87

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

    88

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

    89

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

    90

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

    91

    92

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

    93

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

    94

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

    95

    96

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

    97

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

    98

        # Scintilla sample property files.

    99

   100

        # Global default styles for all languages

   101

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

   102

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

   103

   104

        # Global default styles for all languages

   105

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

   106

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

   107

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

   108

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

   109

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

   110

   111

        # Highlighting styles

   112

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

   113

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

   114

   115

        # Section style

   116

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

   117

        self.StyleSetChangeable(STC_CODE_SECTION, False)

   118

   119

        # Indentation size

   120

        self.SetTabWidth(4)

   121

        self.SetUseTabs(0)

   122

   123

        self.SetCodeLexer()

   124

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

   125

   126

        self.Controler = controler

   127

        self.ParentWindow = window

   128

   129

        self.DisableEvents = True

   130

        self.CurrentAction = None

   131

   132

        self.ResetSearchResults()

   133

   134

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

   135

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

   136

   137

        self.SectionsComments = {}

   138

        for section in self.Controler.SECTIONS_NAMES:

   139

            section_comment = " %s section " % (section)

   140

            len_headers = EDGE_COLUMN - len(section_comment)

   141

            section_comment = \

   142

                self.COMMENT_HEADER * (len_headers / 2) + \

   143

                section_comment + \

   144

                self.COMMENT_HEADER * (len_headers - len_headers / 2)

   145

   146

            self.SectionsComments[section] = {

   147

                "comment": section_comment,

   148

            }

   149

   150

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

   151

            section_infos = self.SectionsComments[section]

   152

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

   153

                section_end = self.SectionsComments[

   154

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

   155

            else:

   156

                section_end = "$"

   157

            section_infos["pattern"] = re.compile(

   158

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

   159

                section_end, re.DOTALL)

   160

   161

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

   162

   163

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

   164

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

   165

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

   166

   167

    def SetCodeLexer(self):

   168

        pass

   169

   170

    def ResetSearchResults(self):

   171

        self.Highlights = []

   172

        self.SearchParams = None

   173

        self.SearchResults = None

   174

        self.CurrentFindHighlight = None

   175

   176

    def OnModification(self, event):

   177

        if not self.DisableEvents:

   178

            mod_type = event.GetModificationType()

   179

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

   180

                if mod_type & wx.stc.STC_MOD_BEFOREINSERT:

   181

                    if self.CurrentAction is None:

   182

                        self.StartBuffering()

   183

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

   184

                        self.Controler.EndBuffering()

   185

                        self.StartBuffering()

   186

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

   187

                    wx.CallAfter(self.RefreshModel)

   188

                elif mod_type & wx.stc.STC_MOD_BEFOREDELETE:

   189

                    if self.CurrentAction is None:

   190

                        self.StartBuffering()

   191

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

   192

                        self.Controler.EndBuffering()

   193

                        self.StartBuffering()

   194

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

   195

                    wx.CallAfter(self.RefreshModel)

   196

        wx.CallAfter(self.RefreshSectionStyling)

   197

        event.Skip()

   198

   199

    def OnDoDrop(self, event):

   200

        try:

   201

            values = eval(event.GetDragText())

   202

        except Exception:

   203

            values = event.GetDragText()

   204

        if isinstance(values, tuple):

   205

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

   206

                self.ResetBuffer()

   207

                event.SetDragText(values[0])

   208

                wx.CallAfter(self.RefreshModel)

   209

            else:

   210

                event.SetDragText("")

   211

        else:

   212

            self.ResetBuffer()

   213

            wx.CallAfter(self.RefreshModel)

   214

        event.Skip()

   215

   216

    # Buffer the last model state

   217

    def RefreshBuffer(self):

   218

        self.Controler.BufferCodeFile()

   219

        if self.ParentWindow is not None:

   220

            self.ParentWindow.RefreshTitle()

   221

            self.ParentWindow.RefreshFileMenu()

   222

            self.ParentWindow.RefreshEditMenu()

   223

            self.ParentWindow.RefreshPageTitles()

   224

   225

    def StartBuffering(self):

   226

        self.Controler.StartBuffering()

   227

        if self.ParentWindow is not None:

   228

            self.ParentWindow.RefreshTitle()

   229

            self.ParentWindow.RefreshFileMenu()

   230

            self.ParentWindow.RefreshEditMenu()

   231

            self.ParentWindow.RefreshPageTitles()

   232

   233

    def ResetBuffer(self):

   234

        if self.CurrentAction is not None:

   235

            self.Controler.EndBuffering()

   236

            self.CurrentAction = None

   237

   238

    def GetCodeText(self):

   239

        parts = self.Controler.GetTextParts()

   240

        text = ""

   241

        for section in self.Controler.SECTIONS_NAMES:

   242

            section_comments = self.SectionsComments[section]

   243

            text += section_comments["comment"]

   244

            if parts[section] == "":

   245

                text += "\n"

   246

            else:

   247

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

   248

                    text += "\n"

   249

                text += parts[section]

   250

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

   251

                    text += "\n"

   252

        return text

   253

   254

    def RefreshView(self, scroll_to_highlight=False):

   255

        self.ResetBuffer()

   256

        self.DisableEvents = True

   257

        old_cursor_pos = self.GetCurrentPos()

   258

        line = self.GetFirstVisibleLine()

   259

        column = self.GetXOffset()

   260

        old_text = self.GetText()

   261

        new_text = self.GetCodeText()

   262

        if old_text != new_text:

   263

            self.SetText(new_text)

   264

            new_cursor_pos = GetCursorPos(old_text, new_text)

   265

            self.LineScroll(column, line)

   266

            if new_cursor_pos is not None:

   267

                self.GotoPos(new_cursor_pos)

   268

            else:

   269

                self.GotoPos(old_cursor_pos)

   270

            self.EmptyUndoBuffer()

   271

        self.DisableEvents = False

   272

   273

        self.RefreshSectionStyling()

   274

   275

        self.ShowHighlights()

   276

   277

    def RefreshSectionStyling(self):

   278

        self.Colourise(0, -1)

   279

   280

        text = self.GetText()

   281

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

   282

            self.SetLineState(line, 0)

   283

   284

        for section in self.Controler.SECTIONS_NAMES:

   285

            section_comments = self.SectionsComments[section]

   286

            start_pos = text.find(section_comments["comment"])

   287

            end_pos = start_pos + len(section_comments["comment"])

   288

            self.StartStyling(start_pos, 0xff)

   289

            self.SetStyling(end_pos - start_pos, STC_CODE_SECTION)

   290

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

   291

   292

        self.StartStyling(end_pos, 0x00)

   293

        self.SetStyling(len(self.GetText()) - end_pos, stc.STC_STYLE_DEFAULT)

   294

   295

    def DoGetBestSize(self):

   296

        return self.ParentWindow.GetPanelBestSize()

   297

   298

    def RefreshModel(self):

   299

        text = self.GetText()

   300

        parts = {}

   301

        for section in self.Controler.SECTIONS_NAMES:

   302

            section_comments = self.SectionsComments[section]

   303

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

   304

            if result is not None:

   305

                parts[section] = result.group(1)

   306

            else:

   307

                parts[section] = ""

   308

        self.Controler.SetTextParts(parts)

   309

        self.ResetSearchResults()

   310

   311

    def OnKeyPressed(self, event):

   312

        if self.CallTipActive():

   313

            self.CallTipCancel()

   314

        key = event.GetKeyCode()

   315

        current_pos = self.GetCurrentPos()

   316

        selected = self.GetSelection()

   317

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

   318

   319

        # Test if caret is before Windows like new line

   320

        text = self.GetText()

   321

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

   322

            newline_size = 2

   323

        else:

   324

            newline_size = 1

   325

   326

        # Disable to type any character in section header lines

   327

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

   328

           not text_selected and \

   329

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

   330

            return

   331

   332

        # Disable to delete line between code and header lines

   333

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

   334

              (key == wx.WXK_BACK and

   335

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

   336

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

   337

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

   338

            return

   339

   340

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

   341

            # Tips

   342

            if event.ShiftDown():

   343

                pass

   344

            # Code completion

   345

            else:

   346

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

   347

   348

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

   349

                                            for var in self.Controler.GetVariables()]

   350

                keywords.sort()

   351

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

   352

        else:

   353

            event.Skip()

   354

   355

    def OnKillFocus(self, event):

   356

        self.AutoCompCancel()

   357

        event.Skip()

   358

   359

    def OnUpdateUI(self, event):

   360

        # check for matching braces

   361

        braceAtCaret = -1

   362

        braceOpposite = -1

   363

        charBefore = None

   364

        caretPos = self.GetCurrentPos()

   365

   366

        if caretPos > 0:

   367

            charBefore = self.GetCharAt(caretPos - 1)

   368

            styleBefore = self.GetStyleAt(caretPos - 1)

   369

   370

        # check before

   371

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

   372

            braceAtCaret = caretPos - 1

   373

   374

        # check after

   375

        if braceAtCaret < 0:

   376

            charAfter = self.GetCharAt(caretPos)

   377

            styleAfter = self.GetStyleAt(caretPos)

   378

   379

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

   380

                braceAtCaret = caretPos

   381

   382

        if braceAtCaret >= 0:

   383

            braceOpposite = self.BraceMatch(braceAtCaret)

   384

   385

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

   386

            self.BraceBadLight(braceAtCaret)

   387

        else:

   388

            self.BraceHighlight(braceAtCaret, braceOpposite)

   389

   390

        selected_text = self.GetSelectedText()

   391

        if selected_text:

   392

            self.ParentWindow.SetCopyBuffer(selected_text, True)

   393

   394

    def OnMarginClick(self, event):

   395

        # fold and unfold as needed

   396

        if event.GetMargin() == 2:

   397

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

   398

                self.FoldAll()

   399

            else:

   400

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

   401

   402

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

   403

                    if event.GetShift():

   404

                        self.SetFoldExpanded(lineClicked, True)

   405

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

   406

                    elif event.GetControl():

   407

                        if self.GetFoldExpanded(lineClicked):

   408

                            self.SetFoldExpanded(lineClicked, False)

   409

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

   410

                        else:

   411

                            self.SetFoldExpanded(lineClicked, True)

   412

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

   413

                    else:

   414

                        self.ToggleFold(lineClicked)

   415

        event.Skip()

   416

   417

    def FoldAll(self):

   418

        lineCount = self.GetLineCount()

   419

        expanding = True

   420

   421

        # find out if we are folding or unfolding

   422

        for lineNum in range(lineCount):

   423

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

   424

                expanding = not self.GetFoldExpanded(lineNum)

   425

                break

   426

   427

        lineNum = 0

   428

   429

        while lineNum < lineCount:

   430

            level = self.GetFoldLevel(lineNum)

   431

            if level & stc.STC_FOLDLEVELHEADERFLAG and \

   432

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

   433

   434

                if expanding:

   435

                    self.SetFoldExpanded(lineNum, True)

   436

                    lineNum = self.Expand(lineNum, True)

   437

                    lineNum = lineNum - 1

   438

                else:

   439

                    lastChild = self.GetLastChild(lineNum, -1)

   440

                    self.SetFoldExpanded(lineNum, False)

   441

   442

                    if lastChild > lineNum:

   443

                        self.HideLines(lineNum+1, lastChild)

   444

   445

            lineNum = lineNum + 1

   446

   447

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

   448

        lastChild = self.GetLastChild(line, level)

   449

        line = line + 1

   450

   451

        while line <= lastChild:

   452

            if force:

   453

                if visLevels > 0:

   454

                    self.ShowLines(line, line)

   455

                else:

   456

                    self.HideLines(line, line)

   457

            else:

   458

                if doExpand:

   459

                    self.ShowLines(line, line)

   460

   461

            if level == -1:

   462

                level = self.GetFoldLevel(line)

   463

   464

            if level & stc.STC_FOLDLEVELHEADERFLAG:

   465

                if force:

   466

                    if visLevels > 1:

   467

                        self.SetFoldExpanded(line, True)

   468

                    else:

   469

                        self.SetFoldExpanded(line, False)

   470

   471

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

   472

   473

                else:

   474

                    if doExpand and self.GetFoldExpanded(line):

   475

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

   476

                    else:

   477

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

   478

            else:

   479

                line = line + 1

   480

   481

        return line

   482

   483

    def Cut(self):

   484

        self.ResetBuffer()

   485

        self.DisableEvents = True

   486

        self.CmdKeyExecute(wx.stc.STC_CMD_CUT)

   487

        self.DisableEvents = False

   488

        self.RefreshModel()

   489

        self.RefreshBuffer()

   490

   491

    def Copy(self):

   492

        self.CmdKeyExecute(wx.stc.STC_CMD_COPY)

   493

        self.ParentWindow.RefreshEditMenu()

   494

   495

    def Paste(self):

   496

        self.ResetBuffer()