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 editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    39

from util.BitmapLibrary import GetBitmap

    40

from util.TranslationCatalogs import NoTranslate

    41

from graphics.GraphicCommons import ERROR_HIGHLIGHT, SEARCH_RESULT_HIGHLIGHT, REFRESH_HIGHLIGHT_PERIOD

    42

    43

    44

[STC_CODE_ERROR, STC_CODE_SEARCH_RESULT,

    45

 STC_CODE_SECTION] = range(15, 18)

    46

    47

HIGHLIGHT_TYPES = {

    48

    ERROR_HIGHLIGHT: STC_CODE_ERROR,

    49

    SEARCH_RESULT_HIGHLIGHT: STC_CODE_SEARCH_RESULT,

    50

}

    51

    52

EDGE_COLUMN = 80

    53

    54

    55

class CodeEditor(CustomStyledTextCtrl):

    56

    57

    KEYWORDS = []

    58

    COMMENT_HEADER = ""

    59

    60

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

    61

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

    62

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

    63

    64

        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)

    65

        self.SetMarginWidth(1, 25)

    66

    67

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

    68

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

    69

        self.SetMargins(0, 0)

    70

    71

        self.SetViewWhiteSpace(False)

    72

    73

        self.SetEdgeMode(stc.STC_EDGE_BACKGROUND)

    74

        self.SetEdgeColumn(EDGE_COLUMN)

    75

    76

        # Setup a margin to hold fold markers

    77

        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)

    78

        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)

    79

        self.SetMarginSensitive(2, True)

    80

        self.SetMarginWidth(2, 12)

    81

    82

        # Like a flattened tree control using square headers

    83

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

    84

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

    85

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

    86

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

    87

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

    88

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

    89

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

    90

    91

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

    92

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

    93

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

    94

    95

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

    96

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

    97

        # Scintilla sample property files.

    98

    99

        # Global default styles for all languages

   100

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

   101

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

   102

   103

        # Global default styles for all languages

   104

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

   105

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

   106

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

   107

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

   108

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

   109

   110

        # Highlighting styles

   111

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

   112

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

   113

   114

        # Section style

   115

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

   116

        self.StyleSetChangeable(STC_CODE_SECTION, False)

   117

   118

        # Indentation size

   119

        self.SetTabWidth(4)

   120

        self.SetUseTabs(0)

   121

   122

        self.SetCodeLexer()

   123

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

   124

   125

        self.Controler = controler

   126

        self.ParentWindow = window

   127

   128

        self.DisableEvents = True

   129

        self.CurrentAction = None

   130

   131

        self.ResetSearchResults()

   132

   133

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

   134

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

   135

   136

        self.SectionsComments = {}

   137

        for section in self.Controler.SECTIONS_NAMES:

   138

            section_comment = " %s section " % (section)

   139

            len_headers = EDGE_COLUMN - len(section_comment)

   140

            section_comment = \

   141

                self.COMMENT_HEADER * (len_headers / 2) + \

   142

                section_comment + \

   143

                self.COMMENT_HEADER * (len_headers - len_headers / 2)

   144

   145

            self.SectionsComments[section] = {

   146

                "comment": section_comment,

   147

            }

   148

   149

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

   150

            section_infos = self.SectionsComments[section]

   151

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

   152

                section_end = self.SectionsComments[

   153

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

   154

            else:

   155

                section_end = "$"

   156

            section_infos["pattern"] = re.compile(

   157

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

   158

                section_end, re.DOTALL)

   159

   160

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

   161

   162

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

   163

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

   164

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

   165

   166

    def SetCodeLexer(self):

   167

        pass

   168

   169

    def ResetSearchResults(self):

   170

        self.Highlights = []

   171

        self.SearchParams = None

   172

        self.SearchResults = None

   173

        self.CurrentFindHighlight = None

   174

   175

    def OnModification(self, event):

   176

        if not self.DisableEvents:

   177

            mod_type = event.GetModificationType()

   178

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

   179

                if mod_type & wx.stc.STC_MOD_BEFOREINSERT:

   180

                    if self.CurrentAction is None:

   181

                        self.StartBuffering()

   182

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

   183

                        self.Controler.EndBuffering()

   184

                        self.StartBuffering()

   185

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

   186

                    wx.CallAfter(self.RefreshModel)

   187

                elif mod_type & wx.stc.STC_MOD_BEFOREDELETE:

   188

                    if self.CurrentAction is None:

   189

                        self.StartBuffering()

   190

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

   191

                        self.Controler.EndBuffering()

   192

                        self.StartBuffering()

   193

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

   194

                    wx.CallAfter(self.RefreshModel)

   195

        wx.CallAfter(self.RefreshSectionStyling)

   196

        event.Skip()

   197

   198

    def OnDoDrop(self, event):

   199

        try:

   200

            values = eval(event.GetDragText())

   201

        except Exception:

   202

            values = event.GetDragText()

   203

        if isinstance(values, tuple):

   204

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

   205

                self.ResetBuffer()

   206

                event.SetDragText(values[0])

   207

                wx.CallAfter(self.RefreshModel)

   208

            else:

   209

                event.SetDragText("")

   210

        else:

   211

            self.ResetBuffer()

   212

            wx.CallAfter(self.RefreshModel)

   213

        event.Skip()

   214

   215

    # Buffer the last model state

   216

    def RefreshBuffer(self):

   217

        self.Controler.BufferCodeFile()

   218

        if self.ParentWindow is not None:

   219

            self.ParentWindow.RefreshTitle()

   220

            self.ParentWindow.RefreshFileMenu()

   221

            self.ParentWindow.RefreshEditMenu()

   222

            self.ParentWindow.RefreshPageTitles()

   223

   224

    def StartBuffering(self):

   225

        self.Controler.StartBuffering()

   226

        if self.ParentWindow is not None:

   227

            self.ParentWindow.RefreshTitle()

   228

            self.ParentWindow.RefreshFileMenu()

   229

            self.ParentWindow.RefreshEditMenu()

   230

            self.ParentWindow.RefreshPageTitles()

   231

   232

    def ResetBuffer(self):

   233

        if self.CurrentAction is not None:

   234

            self.Controler.EndBuffering()

   235

            self.CurrentAction = None

   236

   237

    def GetCodeText(self):

   238

        parts = self.Controler.GetTextParts()

   239

        text = ""

   240

        for section in self.Controler.SECTIONS_NAMES:

   241

            section_comments = self.SectionsComments[section]

   242

            text += section_comments["comment"]

   243

            if parts[section] == "":

   244

                text += "\n"

   245

            else:

   246

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

   247

                    text += "\n"

   248

                text += parts[section]

   249

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

   250

                    text += "\n"

   251

        return text

   252

   253

    def RefreshView(self, scroll_to_highlight=False):

   254

        self.ResetBuffer()

   255

        self.DisableEvents = True

   256

        old_cursor_pos = self.GetCurrentPos()

   257

        line = self.GetFirstVisibleLine()

   258

        column = self.GetXOffset()

   259

        old_text = self.GetText()

   260

        new_text = self.GetCodeText()

   261

        if old_text != new_text:

   262

            self.SetText(new_text)

   263

            new_cursor_pos = GetCursorPos(old_text, new_text)

   264

            self.LineScroll(column, line)

   265

            if new_cursor_pos is not None:

   266

                self.GotoPos(new_cursor_pos)

   267

            else:

   268

                self.GotoPos(old_cursor_pos)

   269

            self.EmptyUndoBuffer()

   270

        self.DisableEvents = False

   271

   272

        self.RefreshSectionStyling()

   273

   274

        self.ShowHighlights()

   275

   276

    def RefreshSectionStyling(self):

   277

        self.Colourise(0, -1)

   278

   279

        text = self.GetText()

   280

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

   281

            self.SetLineState(line, 0)

   282

   283

        for section in self.Controler.SECTIONS_NAMES:

   284

            section_comments = self.SectionsComments[section]

   285

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

   286

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

   287

            self.StartStyling(start_pos, 0xff)

   288

            self.SetStyling(end_pos - start_pos, STC_CODE_SECTION)

   289

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

   290

   291

        self.StartStyling(end_pos, 0x00)

   292

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

   293

   294

    def DoGetBestSize(self):

   295

        return self.ParentWindow.GetPanelBestSize()

   296

   297

    def RefreshModel(self):

   298

        text = self.GetText()

   299

        parts = {}

   300

        for section in self.Controler.SECTIONS_NAMES:

   301

            section_comments = self.SectionsComments[section]

   302

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

   303

            if result is not None:

   304

                parts[section] = result.group(1)

   305

            else:

   306

                parts[section] = ""

   307

        self.Controler.SetTextParts(parts)

   308

        self.ResetSearchResults()

   309

   310

    def OnKeyPressed(self, event):

   311

        if self.CallTipActive():

   312

            self.CallTipCancel()

   313

        key = event.GetKeyCode()

   314

        current_pos = self.GetCurrentPos()

   315

        selected = self.GetSelection()

   316

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

   317

   318

        # Test if caret is before Windows like new line

   319

        text = self.GetText()

   320

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

   321

            newline_size = 2

   322

        else:

   323

            newline_size = 1

   324

   325

        # Disable to type any character in section header lines

   326

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

   327

           not text_selected and \

   328

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

   329

            return

   330

   331

        # Disable to delete line between code and header lines

   332

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

   333

              (key == wx.WXK_BACK and

   334

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

   335

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

   336

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

   337

            return

   338

   339

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

   340

            # Tips

   341

            if event.ShiftDown():

   342

                pass

   343

            # Code completion

   344

            else:

   345

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

   346

   347

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

   348

                                            for var in self.Controler.GetVariables()]

   349

                keywords.sort()

   350

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

   351

        else:

   352

            event.Skip()

   353

   354

    def OnKillFocus(self, event):

   355

        self.AutoCompCancel()

   356

        event.Skip()

   357

   358

    def OnUpdateUI(self, event):

   359

        # check for matching braces

   360

        braceAtCaret = -1

   361

        braceOpposite = -1

   362

        charBefore = None

   363

        caretPos = self.GetCurrentPos()

   364

   365

        if caretPos > 0:

   366

            charBefore = self.GetCharAt(caretPos - 1)

   367

            styleBefore = self.GetStyleAt(caretPos - 1)

   368

   369

        # check before

   370

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

   371

            braceAtCaret = caretPos - 1

   372

   373

        # check after

   374

        if braceAtCaret < 0:

   375

            charAfter = self.GetCharAt(caretPos)

   376

            styleAfter = self.GetStyleAt(caretPos)

   377

   378

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

   379

                braceAtCaret = caretPos

   380

   381

        if braceAtCaret >= 0:

   382

            braceOpposite = self.BraceMatch(braceAtCaret)

   383

   384

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

   385

            self.BraceBadLight(braceAtCaret)

   386

        else:

   387

            self.BraceHighlight(braceAtCaret, braceOpposite)

   388

   389

        selected_text = self.GetSelectedText()

   390

        if selected_text:

   391

            self.ParentWindow.SetCopyBuffer(selected_text, True)

   392

   393

    def OnMarginClick(self, event):

   394

        # fold and unfold as needed

   395

        if event.GetMargin() == 2:

   396

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

   397

                self.FoldAll()

   398

            else:

   399

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

   400

   401

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

   402

                    if event.GetShift():

   403

                        self.SetFoldExpanded(lineClicked, True)

   404

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

   405

                    elif event.GetControl():

   406

                        if self.GetFoldExpanded(lineClicked):

   407

                            self.SetFoldExpanded(lineClicked, False)

   408

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

   409

                        else:

   410

                            self.SetFoldExpanded(lineClicked, True)

   411

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

   412

                    else:

   413

                        self.ToggleFold(lineClicked)

   414

        event.Skip()

   415

   416

    def FoldAll(self):

   417

        lineCount = self.GetLineCount()

   418

        expanding = True

   419

   420

        # find out if we are folding or unfolding

   421

        for lineNum in range(lineCount):

   422

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

   423

                expanding = not self.GetFoldExpanded(lineNum)

   424

                break

   425

   426

        lineNum = 0

   427

   428

        while lineNum < lineCount:

   429

            level = self.GetFoldLevel(lineNum)

   430

            if level & stc.STC_FOLDLEVELHEADERFLAG and \

   431

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

   432

   433

                if expanding:

   434

                    self.SetFoldExpanded(lineNum, True)

   435

                    lineNum = self.Expand(lineNum, True)

   436

                    lineNum = lineNum - 1

   437

                else:

   438

                    lastChild = self.GetLastChild(lineNum, -1)

   439

                    self.SetFoldExpanded(lineNum, False)

   440

   441

                    if lastChild > lineNum:

   442

                        self.HideLines(lineNum+1, lastChild)

   443

   444

            lineNum = lineNum + 1

   445

   446

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

   447

        lastChild = self.GetLastChild(line, level)

   448

        line = line + 1

   449

   450

        while line <= lastChild:

   451

            if force:

   452

                if visLevels > 0:

   453

                    self.ShowLines(line, line)

   454

                else:

   455

                    self.HideLines(line, line)

   456

            else:

   457

                if doExpand:

   458

                    self.ShowLines(line, line)

   459

   460

            if level == -1:

   461

                level = self.GetFoldLevel(line)

   462

   463

            if level & stc.STC_FOLDLEVELHEADERFLAG:

   464

                if force:

   465

                    if visLevels > 1:

   466

                        self.SetFoldExpanded(line, True)

   467

                    else:

   468

                        self.SetFoldExpanded(line, False)

   469

   470

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

   471

   472

                else:

   473

                    if doExpand and self.GetFoldExpanded(line):

   474

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

   475

                    else:

   476

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

   477

            else:

   478

                line = line + 1

   479

   480

        return line

   481

   482

    def Cut(self):

   483

        self.ResetBuffer()

   484

        self.DisableEvents = True

   485

        self.CmdKeyExecute(wx.stc.STC_CMD_CUT)

   486

        self.DisableEvents = False

   487

        self.RefreshModel()

   488

        self.RefreshBuffer()

   489

   490

    def Copy(self):

   491

        self.CmdKeyExecute(wx.stc.STC_CMD_COPY)

   492

        self.ParentWindow.RefreshEditMenu()

   493

   494

    def Paste(self):

   495

        self.ResetBuffer()

   496

        self.DisableEvents = True