1

#!/usr/bin/env python

     2

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

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

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

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

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

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

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

    15

#

    16

#This library 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 GNU

    19

#General Public License for more details.

    20

#

    21

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

    22

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

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

import wx

    26

    27

from plcopen.structures import *

    28

from PLCControler import ITEM_POU

    29

    30

from Dialogs import *

    31

    32

from types import TupleType

    33

    34

SCROLLBAR_UNIT = 10

    35

WINDOW_BORDER = 10

    36

SCROLL_ZONE = 10

    37

    38

def AppendMenu(parent, help, id, kind, text):

    39

    if wx.VERSION >= (2, 6, 0):

    40

        parent.Append(help=help, id=id, kind=kind, text=text)

    41

    else:

    42

        parent.Append(helpString=help, id=id, kind=kind, item=text)

    43

    44

if wx.Platform == '__WXMSW__':

    45

    faces = { 'times': 'Times New Roman',

    46

              'mono' : 'Courier New',

    47

              'helv' : 'Arial',

    48

              'other': 'Comic Sans MS',

    49

              'size' : 20,

    50

             }

    51

else:

    52

    faces = { 'times': 'Times',

    53

              'mono' : 'Courier',

    54

              'helv' : 'Helvetica',

    55

              'other': 'new century schoolbook',

    56

              'size' : 20,

    57

             }

    58

    59

#-------------------------------------------------------------------------------

    60

#                       Graphic elements Viewer base class

    61

#-------------------------------------------------------------------------------

    62

    63

# ID Constants for alignment menu items

    64

[ID_VIEWERALIGNMENTMENUITEMS0, ID_VIEWERALIGNMENTMENUITEMS1,

    65

 ID_VIEWERALIGNMENTMENUITEMS2, ID_VIEWERALIGNMENTMENUITEMS4,

    66

 ID_VIEWERALIGNMENTMENUITEMS5, ID_VIEWERALIGNMENTMENUITEMS6,

    67

] = [wx.NewId() for _init_coll_AlignmentMenu_Items in range(6)]

    68

    69

# ID Constants for contextual menu items

    70

[ID_VIEWERCONTEXTUALMENUITEMS0, ID_VIEWERCONTEXTUALMENUITEMS1,

    71

 ID_VIEWERCONTEXTUALMENUITEMS2, ID_VIEWERCONTEXTUALMENUITEMS3,

    72

 ID_VIEWERCONTEXTUALMENUITEMS5, ID_VIEWERCONTEXTUALMENUITEMS6,

    73

 ID_VIEWERCONTEXTUALMENUITEMS8, ID_VIEWERCONTEXTUALMENUITEMS9,

    74

 ID_VIEWERCONTEXTUALMENUITEMS11, ID_VIEWERCONTEXTUALMENUITEMS12,

    75

 ID_VIEWERCONTEXTUALMENUITEMS14, ID_VIEWERCONTEXTUALMENUITEMS16,

    76

 ID_VIEWERCONTEXTUALMENUITEMS17,

    77

] = [wx.NewId() for _init_coll_ContextualMenu_Items in range(13)]

    78

    79

    80

class ViewerDropTarget(wx.TextDropTarget):

    81

    82

    def __init__(self, parent):

    83

        wx.TextDropTarget.__init__(self)

    84

        self.ParentWindow = parent

    85

    86

    def OnDropText(self, x, y, data):

    87

        x, y = self.ParentWindow.CalcUnscrolledPosition(x, y)

    88

        scaling = self.ParentWindow.Scaling

    89

        message = None

    90

        try:

    91

            values = eval(data)

    92

        except:

    93

            message = "Invalid value \"%s\" for viewer block"%data

    94

            values = None

    95

        if not isinstance(values, TupleType):

    96

            message = "Invalid value \"%s\" for viewer block"%data

    97

            values = None

    98

        if values is not None:

    99

            if values[1] == "program":

   100

                message = "Programs can't be used by other POUs!"

   101

            elif values[1] in ["function", "functionBlock", "program"]:

   102

                name, type = self.ParentWindow.Controler.GetEditedElementType(self.ParentWindow.GetTagName())

   103

                if name == values[0]:

   104

                    message = "\"%s\" can't use itself!"%name

   105

                elif type == "function" and values[1] != "function":

   106

                    message = "Function Blocks can't be used by Functions!"

   107

                elif self.ParentWindow.Controler.PouIsUsedBy(name, values[0]):

   108

                    message = "\"%s\" is already used by \"%s\"!"%(name, values[0])

   109

                else:

   110

                    blockname = values[2]

   111

                    if values[1] != "function" and blockname == "":

   112

                        dialog = wx.TextEntryDialog(self.ParentWindow, "Block name", "Please enter a block name", "", wx.OK|wx.CANCEL|wx.CENTRE)

   113

                        if dialog.ShowModal():

   114

                            blockname = dialog.GetValue()

   115

                        dialog.Destroy()

   116

                    if blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames()]:

   117

                        message = "\"%s\" pou already exists!"%blockname

   118

                    elif blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(self.ParentWindow.GetTagName())]:

   119

                        message = "\"%s\" element for this pou already exists!"%blockname

   120

                    else:

   121

                        id = self.ParentWindow.GetNewId()

   122

                        block = FBD_Block(self.ParentWindow, values[0], blockname, id)

   123

                        width, height = block.GetMinSize()

   124

                        if scaling is not None:

   125

                            x = round(float(x) / float(scaling[0])) * scaling[0]

   126

                            y = round(float(y) / float(scaling[1])) * scaling[1]

   127

                            width = round(float(width) / float(scaling[0]) + 0.5) * scaling[0]

   128

                            height = round(float(height) / float(scaling[1]) + 0.5) * scaling[1]

   129

                        block.SetPosition(x, y)

   130

                        block.SetSize(width, height)

   131

                        self.ParentWindow.AddBlock(block)

   132

                        self.ParentWindow.Controler.AddEditedElementBlock(self.ParentWindow.GetTagName(), id, values[0], blockname)

   133

                        self.ParentWindow.RefreshBlockModel(block)

   134

                        self.ParentWindow.RefreshBuffer()

   135

                        self.ParentWindow.RefreshScrollBars()

   136

                        self.ParentWindow.ParentWindow.RefreshVariablePanel(self.ParentWindow.GetTagName())

   137

                        self.ParentWindow.Refresh(False)

   138

            elif values[1] != "location":

   139

                if values[3] == self.ParentWindow.GetTagName():

   140

                    id = self.ParentWindow.GetNewId()

   141

                    if values[1] == "Output":

   142

                        var_type = OUTPUT

   143

                    elif values[1] == "InOut":

   144

                        var_type = INPUT

   145

                    else:

   146

                        var_type = INPUT

   147

                    variable = FBD_Variable(self.ParentWindow, var_type, values[0], values[2], id)

   148

                    width, height = variable.GetMinSize()

   149

                    if scaling is not None:

   150

                        x = round(float(x) / float(scaling[0])) * scaling[0]

   151

                        y = round(float(y) / float(scaling[1])) * scaling[1]

   152

                        width = round(float(width) / float(scaling[0]) + 0.5) * scaling[0]

   153

                        height = round(float(height) / float(scaling[1]) + 0.5) * scaling[1]

   154

                    variable.SetPosition(x, y)

   155

                    variable.SetSize(width, height)

   156

                    self.ParentWindow.AddBlock(variable)

   157

                    self.ParentWindow.Controler.AddEditedElementVariable(self.ParentWindow.GetTagName(), id, var_type)

   158

                    self.ParentWindow.RefreshVariableModel(variable)

   159

                    self.ParentWindow.RefreshBuffer()

   160

                    self.ParentWindow.RefreshScrollBars()

   161

                    self.ParentWindow.Refresh(False)

   162

                else:

   163

                    message = "Variable don't belong to this POU!"

   164

        wx.CallAfter(self.ShowMessage, message)

   165

   166

    def ShowMessage(self, message):

   167

        if message is not None:

   168

            message = wx.MessageDialog(self.ParentWindow, message, "Error", wx.OK|wx.ICON_ERROR)

   169

            message.ShowModal()

   170

            message.Destroy()

   171

   172

if wx.VERSION >= (2, 8, 0):

   173

    import wx.aui

   174

   175

    class MDIViewer(wx.aui.AuiMDIChildFrame):

   176

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

   177

            wx.aui.AuiMDIChildFrame.__init__(self, parent, -1, title = "")

   178

   179

            sizer = wx.BoxSizer(wx.HORIZONTAL)

   180

   181

            self.Viewer = Viewer(self, tagname, window, controler)

   182

   183

            sizer.AddWindow(self.Viewer, 1, border=0, flag=wx.GROW)

   184

   185

            self.SetSizer(sizer)

   186

   187

        def GetViewer(self):

   188

            return self.Viewer

   189

   190

"""

   191

Class that implements a Viewer based on a wx.ScrolledWindow for drawing and 

   192

manipulating graphic elements

   193

"""

   194

   195

class Viewer(wx.ScrolledWindow):

   196

   197

    if wx.VERSION < (2, 6, 0):

   198

        def Bind(self, event, function, id = None):

   199

            if id is not None:

   200

                event(self, id, function)

   201

            else:

   202

                event(self, function)

   203

   204

    # Create Alignment Menu items

   205

    def _init_coll_AlignmentMenu_Items(self, parent):

   206

        # Create menu items

   207

        AppendMenu(parent, help='', id=ID_VIEWERALIGNMENTMENUITEMS0,

   208

              kind=wx.ITEM_NORMAL, text=u'Left')

   209

        AppendMenu(parent, help='', id=ID_VIEWERALIGNMENTMENUITEMS1,

   210

              kind=wx.ITEM_NORMAL, text=u'Center')

   211

        AppendMenu(parent, help='', id=ID_VIEWERALIGNMENTMENUITEMS2,

   212

              kind=wx.ITEM_NORMAL, text=u'Right')

   213

        parent.AppendSeparator()

   214

        AppendMenu(parent, help='', id=ID_VIEWERALIGNMENTMENUITEMS4,

   215

              kind=wx.ITEM_NORMAL, text=u'Top')

   216

        AppendMenu(parent, help='', id=ID_VIEWERALIGNMENTMENUITEMS5,

   217

              kind=wx.ITEM_NORMAL, text=u'Middle')

   218

        AppendMenu(parent, help='', id=ID_VIEWERALIGNMENTMENUITEMS6,

   219

              kind=wx.ITEM_NORMAL, text=u'Bottom')

   220

        # Link menu event to corresponding called functions

   221

        self.Bind(wx.EVT_MENU, self.OnAlignLeftMenu,

   222

              id=ID_VIEWERALIGNMENTMENUITEMS0)

   223

        self.Bind(wx.EVT_MENU, self.OnAlignCenterMenu,

   224

              id=ID_VIEWERALIGNMENTMENUITEMS1)

   225

        self.Bind(wx.EVT_MENU, self.OnAlignRightMenu,

   226

              id=ID_VIEWERALIGNMENTMENUITEMS2)

   227

        self.Bind(wx.EVT_MENU, self.OnAlignTopMenu,

   228

              id=ID_VIEWERALIGNMENTMENUITEMS4)

   229

        self.Bind(wx.EVT_MENU, self.OnAlignMiddleMenu,

   230

              id=ID_VIEWERALIGNMENTMENUITEMS5)

   231

        self.Bind(wx.EVT_MENU, self.OnAlignBottomMenu,

   232

              id=ID_VIEWERALIGNMENTMENUITEMS6)

   233

   234

    # Create Contextual Menu items

   235

    def _init_coll_ContextualMenu_Items(self, parent):

   236

        # Create menu items

   237

        AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS0,

   238

              kind=wx.ITEM_RADIO, text=u'No Modifier')

   239

        AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS1,

   240

              kind=wx.ITEM_RADIO, text=u'Negated')

   241

        AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS2,

   242

              kind=wx.ITEM_RADIO, text=u'Rising Edge')

   243

        AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS3,

   244

              kind=wx.ITEM_RADIO, text=u'Falling Edge')

   245

        parent.AppendSeparator()

   246

        AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS5,

   247

              kind=wx.ITEM_NORMAL, text=u'Add Wire Segment')

   248

        AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS6,

   249

              kind=wx.ITEM_NORMAL, text=u'Delete Wire Segment')

   250

        parent.AppendSeparator()

   251

        AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS8,

   252

              kind=wx.ITEM_NORMAL, text=u'Add Divergence Branch')

   253

        AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS9,

   254

              kind=wx.ITEM_NORMAL, text=u'Delete Divergence Branch')

   255

        parent.AppendSeparator()

   256

        AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS11,

   257

              kind=wx.ITEM_NORMAL, text=u'Clear Execution Order')

   258

        AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS12,

   259

              kind=wx.ITEM_NORMAL, text=u'Reset Execution Order')

   260

        parent.AppendSeparator()

   261

        parent.AppendMenu(ID_VIEWERCONTEXTUALMENUITEMS14, "Alignment", self.AlignmentMenu)

   262

        parent.AppendSeparator()

   263

        AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS16,

   264

              kind=wx.ITEM_NORMAL, text=u'Edit Block')

   265

        AppendMenu(parent, help='', id=ID_VIEWERCONTEXTUALMENUITEMS17,

   266

              kind=wx.ITEM_NORMAL, text=u'Delete')

   267

        # Link menu event to corresponding called functions

   268

        self.Bind(wx.EVT_MENU, self.OnNoModifierMenu,

   269

              id=ID_VIEWERCONTEXTUALMENUITEMS0)

   270

        self.Bind(wx.EVT_MENU, self.OnNegatedMenu,

   271

              id=ID_VIEWERCONTEXTUALMENUITEMS1)

   272

        self.Bind(wx.EVT_MENU, self.OnRisingEdgeMenu,

   273

              id=ID_VIEWERCONTEXTUALMENUITEMS2)

   274

        self.Bind(wx.EVT_MENU, self.OnFallingEdgeMenu,

   275

              id=ID_VIEWERCONTEXTUALMENUITEMS3)

   276

        self.Bind(wx.EVT_MENU, self.OnAddSegmentMenu,

   277

              id=ID_VIEWERCONTEXTUALMENUITEMS5)

   278

        self.Bind(wx.EVT_MENU, self.OnDeleteSegmentMenu,

   279

              id=ID_VIEWERCONTEXTUALMENUITEMS6)

   280

        self.Bind(wx.EVT_MENU, self.OnAddBranchMenu,

   281

              id=ID_VIEWERCONTEXTUALMENUITEMS8)

   282

        self.Bind(wx.EVT_MENU, self.OnDeleteBranchMenu,

   283

              id=ID_VIEWERCONTEXTUALMENUITEMS9)

   284

        self.Bind(wx.EVT_MENU, self.OnClearExecutionOrderMenu,

   285

              id=ID_VIEWERCONTEXTUALMENUITEMS11)

   286

        self.Bind(wx.EVT_MENU, self.OnResetExecutionOrderMenu,

   287

              id=ID_VIEWERCONTEXTUALMENUITEMS12)

   288

        self.Bind(wx.EVT_MENU, self.OnEditBlockMenu,

   289

              id=ID_VIEWERCONTEXTUALMENUITEMS16)

   290

        self.Bind(wx.EVT_MENU, self.OnDeleteMenu,

   291

              id=ID_VIEWERCONTEXTUALMENUITEMS17)

   292

   293

    # Create and initialize Contextual Menu

   294

    def _init_menus(self):

   295

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

   296

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

   297

   298

        self._init_coll_AlignmentMenu_Items(self.AlignmentMenu)

   299

        self._init_coll_ContextualMenu_Items(self.ContextualMenu)

   300

   301

    # Create a new Viewer

   302

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

   303

        wx.ScrolledWindow.__init__(self, parent, pos=wx.Point(0, 0), size=wx.Size(0, 0), 

   304

            style=wx.HSCROLL | wx.VSCROLL)

   305

        self._init_menus()

   306

        # Adding a rubberband to Viewer

   307

        self.rubberBand = RubberBand(drawingSurface=self)

   308

        self.SetBackgroundColour(wx.Colour(255,255,255))

   309

        self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)

   310

        self.ResetView()

   311

        self.Scaling = None

   312

        self.DrawGrid = True

   313

        self.GridBrush = wx.TRANSPARENT_BRUSH

   314

        self.PageSize = None

   315

        self.PagePen = wx.TRANSPARENT_PEN

   316

        self.DrawingWire = False

   317

        self.current_id = 0

   318

        self.TagName = tagname

   320

   321

        # Initialize Block, Wire and Comment numbers

   322

        self.block_id = self.wire_id = self.comment_id = 0

   323

   324

        # Initialize Viewer mode to Selection mode

   325

        self.Mode = MODE_SELECTION

   326

        self.SavedMode = False

   327

        self.CurrentLanguage = "FBD"

   328

   329

        self.ParentWindow = window

   330

        self.Controler = controler

   331

   332

        self.SetDropTarget(ViewerDropTarget(self))

   333

   334

        dc = wx.ClientDC(self)

   335

        font = wx.Font(faces["size"], wx.SWISS, wx.NORMAL, wx.NORMAL, faceName = faces["mono"])

   336

        dc.SetFont(font)

   337

        width, height = dc.GetTextExtent("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

   338

        while width > 260:

   339

            faces["size"] -= 1

   340

            font = wx.Font(faces["size"], wx.SWISS, wx.NORMAL, wx.NORMAL, faceName = faces["mono"])

   341

            dc.SetFont(font)

   342

            width, height = dc.GetTextExtent("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

   343

        self.SetFont(font)

   344

   345

        # Link Viewer event to corresponding methods

   346

        self.Bind(wx.EVT_PAINT, self.OnPaint)

   347

        self.Bind(wx.EVT_LEFT_DOWN, self.OnViewerLeftDown)

   348

        self.Bind(wx.EVT_LEFT_UP, self.OnViewerLeftUp)

   349

        self.Bind(wx.EVT_LEFT_DCLICK, self.OnViewerLeftDClick)

   350

        self.Bind(wx.EVT_RIGHT_DOWN, self.OnViewerRightDown)

   351

        self.Bind(wx.EVT_RIGHT_UP, self.OnViewerRightUp)

   352

        self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeaveViewer)

   353

        self.Bind(wx.EVT_MOTION, self.OnViewerMotion)

   354

        self.Bind(wx.EVT_CHAR, self.OnChar)

   355

        #self.Bind(wx.EVT_SCROLLWIN, self.OnMoveWindow)

   356

        self.Bind(wx.EVT_SIZE, self.OnMoveWindow)

   357

   358

    def GetScrolledRect(self, rect):

   359

        rect.x, rect.y = self.CalcScrolledPosition(rect.x, rect.y)

   360

        return rect

   361

   362

    def GetScaling(self):

   363

        return self.Scaling

   364

   365

    def SetTagName(self, tagname):

   366

        self.TagName = tagname

   367

   368

    def GetTagName(self):

   369

        return self.TagName

   370

   371

    def IsViewing(self, tagname):

   372

        return self.TagName == tagname

   373

   374

    # Returns a new id

   375

    def GetNewId(self):

   376

        self.current_id += 1

   377

        return self.current_id

   378

   379

    # Destructor

   380

    def __del__(self):

   381

        self.ResetView()

   382

   383

    def GetLogicalDC(self, buffered=False):

   384

        if buffered:

   385

            dc = wx.AutoBufferedPaintDC(self)

   386

        else:

   387

            dc = wx.ClientDC(self)

   388

        dc.SetFont(self.GetFont())

   389

        if wx.VERSION >= (2, 6, 0):

   390

            self.DoPrepareDC(dc)

   391

        else:

   392

            self.PrepareDC(dc)

   393

        return dc

   394

   395

#-------------------------------------------------------------------------------

   396

#                         Element management functions

   397

#-------------------------------------------------------------------------------

   398

   399

    def AddBlock(self, block):

   400

        self.block_id += 1

   401

        self.Blocks[block] = self.block_id

   402

   403

    def AddWire(self, wire):

   404

        self.wire_id += 1

   405

        self.Wires[wire] = self.wire_id

   406

   407

    def AddComment(self, comment):

   408

        self.comment_id += 1

   409

        self.Comments[comment] = self.comment_id

   410

   411

    def IsBlock(self, block):

   412

        return self.Blocks.get(block, False)

   413

   414

    def IsWire(self, wire):

   415

        return self.Wires.get(wire, False)

   416

   417

    def IsComment(self, comment):

   418

        return self.Comments.get(comment, False)

   419

   420

    def RemoveBlock(self, block):

   421

        self.Blocks.pop(block)

   422

   423

    def RemoveWire(self, wire):

   424

        self.Wires.pop(wire)

   425

   426

    def RemoveComment(self, comment):

   427

        self.Comments.pop(comment)

   428

   429

    def GetElements(self, sort_blocks=False, sort_wires=False, sort_comments=False):

   430

        blocks = self.Blocks.keys()

   431

        wires = self.Wires.keys()

   432

        comments = self.Comments.keys()

   433

        if sort_blocks:

   434

            blocks.sort(lambda x,y:self.Blocks[x].__cmp__(self.Blocks[y]))

   435

        if sort_wires:

   436

            wires.sort(lambda x,y:self.Wires[x].__cmp__(self.Wires[y]))

   437

        if sort_comments:

   438

            comments.sort(lambda x,y:self.Comments[x].__cmp__(self.Comments[y]))

   439

        return blocks + wires + comments

   440

   441

#-------------------------------------------------------------------------------

   442

#                              Reset functions

   443

#-------------------------------------------------------------------------------

   444

   445

    # Resets Viewer lists

   446

    def ResetView(self):

   447

        self.Blocks = {}

   448

        self.Wires = {}

   449

        self.Comments = {}

   450

        self.SelectedElement = None

   451

        self.HighlightedElement = None

   452

   453

    # Remove all elements

   454

    def CleanView(self):

   455

        for block in self.Blocks.keys():

   456

            block.Clean()

   457

        self.ResetView()

   458

   459

    # Changes Viewer mode

   460

    def SetMode(self, mode):

   461

        if self.Mode != mode or mode == MODE_SELECTION:

   462

            self.Mode = mode

   463

            self.SavedMode = False

   464

        else:

   465

            self.SavedMode = True

   466

        # Reset selection

   467

        if self.Mode != MODE_SELECTION and self.SelectedElement:

   468

            self.SelectedElement.SetSelected(False)

   469

            self.SelectedElement = None

   470

   471

    # Return current drawing mode

   472

    def GetDrawingMode(self):

   473

        return self.ParentWindow.GetDrawingMode()

   474

   475

    # Buffer the last model state

   476

    def RefreshBuffer(self):

   477

        self.Controler.BufferProject()

   478

        self.ParentWindow.RefreshTitle()

   479

        self.ParentWindow.RefreshEditMenu()

   480

   481

    # Refresh the current scaling

   482

    def RefreshScaling(self, refresh=True):

   483

        properties = self.Controler.GetProjectProperties()

   484

        scaling = properties["scaling"][self.CurrentLanguage]

   485

        if scaling != (0, 0):

   486

            self.Scaling = scaling

   487

            if self.DrawGrid:

   488

                bitmap = wx.EmptyBitmap(*scaling)

   489

                dc = wx.MemoryDC(bitmap)

   490

                dc.SetBackground(wx.Brush(self.GetBackgroundColour()))

   491

                dc.Clear()

   492

                dc.SetPen(wx.Pen(wx.Colour(180, 180, 180)))

   493