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 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

__version__ = "$Revision$"

    26

    27

import os, sys, getopt, wx

    28

import tempfile

    29

import shutil

    30

import random

    31

    32

CWD = os.path.split(os.path.realpath(__file__))[0]

    33

    34

def Bpath(*args):

    35

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

    36

    37

if __name__ == '__main__':

    38

    def usage():

    39

        print "\nUsage of Beremiz.py :"

    40

        print "\n   %s [Projectpath] [Buildpath]\n"%sys.argv[0]

    41

    42

    try:

    43

        opts, args = getopt.getopt(sys.argv[1:], "h", ["help"])

    44

    except getopt.GetoptError:

    45

        # print help information and exit:

    46

        usage()

    47

        sys.exit(2)

    48

    49

    for o, a in opts:

    50

        if o in ("-h", "--help"):

    51

            usage()

    52

            sys.exit()

    53

    54

    if len(args) > 2:

    55

        usage()

    56

        sys.exit()

    57

    elif len(args) == 1:

    58

        projectOpen = args[0]

    59

        buildpath = None

    60

    elif len(args) == 2:

    61

        projectOpen = args[0]

    62

        buildpath = args[1]

    63

    else:

    64

        projectOpen = None

    65

        buildpath = None

    66

    67

    app = wx.PySimpleApp()

    68

    app.SetAppName('beremiz')

    69

    wx.InitAllImageHandlers()

    70

    71

    bmp = wx.Image(Bpath("images","splash.png")).ConvertToBitmap()

    72

    splash=wx.SplashScreen(bmp,wx.SPLASH_CENTRE_ON_SCREEN, 1000, None)

    73

    wx.Yield()

    74

    75

# Import module for internationalization

    76

import gettext

    77

import __builtin__

    78

    79

# Get folder containing translation files

    80

localedir = os.path.join(CWD,"locale")

    81

# Get the default language

    82

langid = wx.LANGUAGE_DEFAULT

    83

# Define translation domain (name of translation files)

    84

domain = "Beremiz"

    85

    86

# Define locale for wx

    87

loc = __builtin__.__dict__.get('loc', None)

    88

if loc is None:

    89

    loc = wx.Locale(langid)

    90

    __builtin__.__dict__['loc'] = loc

    91

# Define location for searching translation files

    92

loc.AddCatalogLookupPathPrefix(localedir)

    93

# Define locale domain

    94

loc.AddCatalog(domain)

    95

    96

def unicode_translation(message):

    97

    return wx.GetTranslation(message).encode("utf-8")

    98

    99

if __name__ == '__main__':

   100

    __builtin__.__dict__['_'] = wx.GetTranslation#unicode_translation

   101

   102

#Quick hack to be able to find Beremiz IEC tools. Should be config params.

   103

base_folder = os.path.split(sys.path[0])[0]

   104

sys.path.append(base_folder)

   105

sys.path.append(os.path.join(base_folder, "plcopeneditor"))

   106

sys.path.append(os.path.join(base_folder, "docutils"))

   107

   108

import wx.lib.buttons, wx.lib.statbmp

   109

import TextCtrlAutoComplete, cPickle

   110

import types, time, re, platform, time, traceback, commands

   111

from plugger import PluginsRoot, MATIEC_ERROR_MODEL

   112

from wxPopen import ProcessLogger

   113

   114

from docutils import *

   115

from PLCOpenEditor import IDEFrame, Viewer, AppendMenu, TITLE, TOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU, TYPESTREE, INSTANCESTREE, LIBRARYTREE, SCALING

   116

from PLCControler import LOCATION_PLUGIN, LOCATION_MODULE, LOCATION_GROUP, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

   117

   118

SCROLLBAR_UNIT = 10

   119

WINDOW_COLOUR = wx.Colour(240,240,240)

   120

TITLE_COLOUR = wx.Colour(200,200,220)

   121

CHANGED_TITLE_COLOUR = wx.Colour(220,200,220)

   122

CHANGED_WINDOW_COLOUR = wx.Colour(255,240,240)

   123

   124

if wx.Platform == '__WXMSW__':

   125

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

   126

              'mono' : 'Courier New',

   127

              'helv' : 'Arial',

   128

              'other': 'Comic Sans MS',

   129

              'size' : 16,

   130

             }

   131

else:

   132

    faces = { 'times': 'Times',

   133

              'mono' : 'Courier',

   134

              'helv' : 'Helvetica',

   135

              'other': 'new century schoolbook',

   136

              'size' : 18,

   137

             }

   138

   139

# Some helpers to tweak GenBitmapTextButtons

   140

# TODO: declare customized classes instead.

   141

gen_mini_GetBackgroundBrush = lambda obj:lambda dc: wx.Brush(obj.GetParent().GetBackgroundColour(), wx.SOLID)

   142

gen_textbutton_GetLabelSize = lambda obj:lambda:(wx.lib.buttons.GenButton._GetLabelSize(obj)[:-1] + (False,))

   143

   144

def make_genbitmaptogglebutton_flat(button):

   145

    button.GetBackgroundBrush = gen_mini_GetBackgroundBrush(button)

   146

    button.labelDelta = 0

   147

    button.SetBezelWidth(0)

   148

    button.SetUseFocusIndicator(False)

   149

   150

# Patch wx.lib.imageutils so that gray is supported on alpha images

   151

import wx.lib.imageutils

   152

from wx.lib.imageutils import grayOut as old_grayOut

   153

def grayOut(anImage):

   154

    if anImage.HasAlpha():

   155

        AlphaData = anImage.GetAlphaData()

   156

    else :

   157

        AlphaData = None

   158

   159

    old_grayOut(anImage)

   160

   161

    if AlphaData is not None:

   162

        anImage.SetAlphaData(AlphaData)

   163

   164

wx.lib.imageutils.grayOut = grayOut

   165

   166

class GenBitmapTextButton(wx.lib.buttons.GenBitmapTextButton):

   167

    def _GetLabelSize(self):

   168

        """ used internally """

   169

        w, h = self.GetTextExtent(self.GetLabel())

   170

        if not self.bmpLabel:

   171

            return w, h, False       # if there isn't a bitmap use the size of the text

   172

   173

        w_bmp = self.bmpLabel.GetWidth()+2

   174

        h_bmp = self.bmpLabel.GetHeight()+2

   175

        height = h + h_bmp

   176

        if w_bmp > w:

   177

            width = w_bmp

   178

        else:

   179

            width = w

   180

        return width, height, False

   181

   182

    def DrawLabel(self, dc, width, height, dw=0, dy=0):

   183

        bmp = self.bmpLabel

   184

        if bmp != None:     # if the bitmap is used

   185

            if self.bmpDisabled and not self.IsEnabled():

   186

                bmp = self.bmpDisabled

   187

            if self.bmpFocus and self.hasFocus:

   188

                bmp = self.bmpFocus

   189

            if self.bmpSelected and not self.up:

   190

                bmp = self.bmpSelected

   191

            bw,bh = bmp.GetWidth(), bmp.GetHeight()

   192

            if not self.up:

   193

                dw = dy = self.labelDelta

   194

            hasMask = bmp.GetMask() != None

   195

        else:

   196

            bw = bh = 0     # no bitmap -> size is zero

   197

   198

        dc.SetFont(self.GetFont())

   199

        if self.IsEnabled():

   200

            dc.SetTextForeground(self.GetForegroundColour())

   201

        else:

   202

            dc.SetTextForeground(wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT))

   203

   204

        label = self.GetLabel()

   205

        tw, th = dc.GetTextExtent(label)        # size of text

   206

        if not self.up:

   207

            dw = dy = self.labelDelta

   208

   209

        pos_x = (width-bw)/2+dw      # adjust for bitmap and text to centre

   210

        pos_y = (height-bh-th)/2+dy

   211

        if bmp !=None:

   212

            dc.DrawBitmap(bmp, pos_x, pos_y, hasMask) # draw bitmap if available

   213

            pos_x = (width-tw)/2+dw      # adjust for bitmap and text to centre

   214

            pos_y += bh + 2

   215

   216

        dc.DrawText(label, pos_x, pos_y)      # draw the text

   217

   218

   219

class GenStaticBitmap(wx.lib.statbmp.GenStaticBitmap):

   220

    """ Customized GenStaticBitmap, fix transparency redraw bug on wx2.8/win32, 

   221

    and accept image name as __init__ parameter, fail silently if file do not exist"""

   222

    def __init__(self, parent, ID, bitmapname,

   223

                 pos = wx.DefaultPosition, size = wx.DefaultSize,

   224

                 style = 0,

   225

                 name = "genstatbmp"):

   226

   227

        bitmappath = Bpath( "images", bitmapname)

   228

        if os.path.isfile(bitmappath):

   229

            bitmap = wx.Bitmap(bitmappath)

   230

        else:

   231

            bitmap = None

   232

        wx.lib.statbmp.GenStaticBitmap.__init__(self, parent, ID, bitmap,

   233

                 pos, size,

   234

                 style,

   235

                 name)

   236

   237

    def OnPaint(self, event):

   238

        dc = wx.PaintDC(self)

   239

        colour = self.GetParent().GetBackgroundColour()

   240

        dc.SetPen(wx.Pen(colour))

   241

        dc.SetBrush(wx.Brush(colour ))

   242

        dc.DrawRectangle(0, 0, *dc.GetSizeTuple())

   243

        if self._bitmap:

   244

            dc.DrawBitmap(self._bitmap, 0, 0, True)

   245

   246

   247

class LogPseudoFile:

   248

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

   249

    def __init__(self, output):

   250

        self.red_white = wx.TextAttr("RED", "WHITE")

   251

        self.red_yellow = wx.TextAttr("RED", "YELLOW")

   252

        self.black_white = wx.TextAttr("BLACK", "WHITE")

   253

        self.default_style = None

   254

        self.output = output

   255

   256

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

   257

        if style is None : style=self.black_white

   258

        self.output.Freeze(); 

   259

        if self.default_style != style: 

   260

            self.output.SetDefaultStyle(style)

   261

            self.default_style = style

   262

        self.output.AppendText(s)

   263

        self.output.ScrollLines(s.count('\n')+1)

   264

        self.output.ShowPosition(self.output.GetLastPosition())

   265

        self.output.Thaw()

   266

   267

    def write_warning(self, s):

   268

        self.write(s,self.red_white)

   269

   270

    def write_error(self, s):

   271

        self.write(s,self.red_yellow)

   272

   273

    def flush(self):

   274

        self.output.SetValue("")

   275

   276

    def isatty(self):

   277

        return false

   278

   279

[ID_BEREMIZ, ID_BEREMIZMAINSPLITTER, 

   280

 ID_BEREMIZPLCCONFIG, ID_BEREMIZLOGCONSOLE, 

   281

 ID_BEREMIZINSPECTOR] = [wx.NewId() for _init_ctrls in range(5)]

   282

   283

[ID_BEREMIZRUNMENUBUILD, ID_BEREMIZRUNMENUSIMULATE, 

   284

 ID_BEREMIZRUNMENURUN, ID_BEREMIZRUNMENUSAVELOG, 

   285

] = [wx.NewId() for _init_coll_EditMenu_Items in range(4)]

   286

   287

class Beremiz(IDEFrame):

   288

   289

    def _init_coll_FileMenu_Items(self, parent):

   290

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

   291

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

   292

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

   293

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

   294

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

   295

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

   298

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

   299

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

   300

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

   301

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

   302

        parent.AppendSeparator()

   303

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

   304

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

   305

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

   306

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

   307

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

   308

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

   309

        parent.AppendSeparator()

   310

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

   311

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

   312

        parent.AppendSeparator()

   313

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

   314

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

   315

   316

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

   317

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

   318

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

   320

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

   321

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

   322

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

   323

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

   324

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

   325

        self.Bind(wx.EVT_MENU, self.OnPropertiesMenu, id=wx.ID_PROPERTIES)

   326

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

   327

   328

    def _init_coll_HelpMenu_Items(self, parent):

   329

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

   330

              kind=wx.ITEM_NORMAL, text=_(u'Beremiz\tF1'))

   331

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

   332

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

   333

        self.Bind(wx.EVT_MENU, self.OnBeremizMenu, id=wx.ID_HELP)

   334

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

   335

   336

    def _init_coll_PLCConfigMainSizer_Items(self, parent):

   337

        parent.AddSizer(self.PLCParamsSizer, 0, border=10, flag=wx.GROW|wx.TOP|wx.LEFT|wx.RIGHT)

   338

        parent.AddSizer(self.PluginTreeSizer, 0, border=10, flag=wx.BOTTOM|wx.LEFT|wx.RIGHT)

   339

   340

    def _init_coll_PLCConfigMainSizer_Growables(self, parent):

   341

        parent.AddGrowableCol(0)

   342

        parent.AddGrowableRow(1)

   343

   344

    def _init_coll_PluginTreeSizer_Growables(self, parent):

   345

        parent.AddGrowableCol(0)

   346

        parent.AddGrowableCol(1)

   347

   348

    def _init_beremiz_sizers(self):

   349

        self.PLCConfigMainSizer = wx.FlexGridSizer(cols=1, hgap=2, rows=2, vgap=2)

   350

        self.PLCParamsSizer = wx.BoxSizer(wx.VERTICAL)

   351

        #self.PluginTreeSizer = wx.FlexGridSizer(cols=3, hgap=0, rows=0, vgap=2)

   352

        self.PluginTreeSizer = wx.FlexGridSizer(cols=2, hgap=0, rows=0, vgap=2)

   353

   354

        self._init_coll_PLCConfigMainSizer_Items(self.PLCConfigMainSizer)

   355

        self._init_coll_PLCConfigMainSizer_Growables(self.PLCConfigMainSizer)

   356

        self._init_coll_PluginTreeSizer_Growables(self.PluginTreeSizer)

   357

   358

        self.PLCConfig.SetSizer(self.PLCConfigMainSizer)

   359

   360

    def _init_ctrls(self, prnt):

   361

        IDEFrame._init_ctrls(self, prnt)

   362

   363

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

   364

        accel = wx.AcceleratorTable([wx.AcceleratorEntry(wx.ACCEL_CTRL|wx.ACCEL_ALT, ord('I'), ID_BEREMIZINSPECTOR)])

   365

        self.SetAcceleratorTable(accel)

   366

   367

        self.PLCConfig = wx.ScrolledWindow(id=ID_BEREMIZPLCCONFIG,

   368

              name='PLCConfig', parent=self.LeftNoteBook, pos=wx.Point(0, 0),

   369

              size=wx.Size(-1, -1), style=wx.TAB_TRAVERSAL|wx.SUNKEN_BORDER|wx.HSCROLL|wx.VSCROLL)

   370

        self.PLCConfig.SetBackgroundColour(wx.WHITE)

   371

        self.PLCConfig.Bind(wx.EVT_LEFT_DOWN, self.OnPanelLeftDown)

   372

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

   373

        self.PLCConfig.Bind(wx.EVT_MOUSEWHEEL, self.OnPLCConfigScroll)

   374

        self.BottomNoteBook.InsertPage(0, self.PLCConfig, _("Topology"), True)

   375

   376

        self.LogConsole = wx.TextCtrl(id=ID_BEREMIZLOGCONSOLE, value='',

   377

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

   378

                  size=wx.Size(0, 0), style=wx.TE_MULTILINE|wx.TE_RICH2)

   379

        self.LogConsole.Bind(wx.EVT_LEFT_DCLICK, self.OnLogConsoleDClick)

   380

        self.BottomNoteBook.AddPage(self.LogConsole, _("Log Console"))

   381

   382

        self._init_beremiz_sizers()

   383

   384

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

   385

        IDEFrame.__init__(self, parent, debug)

   386

        self.Config = wx.ConfigBase.Get()

   387

   388

        self.Log = LogPseudoFile(self.LogConsole)

   389

   390

        self.local_runtime = None

   391

        self.runtime_port = None

   392

        self.local_runtime_tmpdir = None

   393

   394

        self.DisableEvents = False

   395

        # Variable allowing disabling of PLCConfig scroll when Popup shown 

   396

        self.ScrollingEnabled = True

   397

   398

        self.PluginInfos = {}

   399

   400

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

   401

            self.PluginRoot = PluginsRoot(self, self.Log)

   402

            self.Controler = self.PluginRoot

   403

            result = self.PluginRoot.LoadProject(projectOpen, buildpath)

   404

            if not result:

   405

                self.DebugVariablePanel.SetDataProducer(self.PluginRoot)

   406

                self._Refresh(TYPESTREE, INSTANCESTREE, LIBRARYTREE)

   407

                self.RefreshAll()

   408

            else:

   409

                self.ResetView()

   410

                self.ShowErrorMessage(result)

   411

        else:

   412

            self.PluginRoot = plugin_root

   413

            self.Controler = plugin_root

   414

            if plugin_root is not None:

   415

                self._Refresh(TYPESTREE, INSTANCESTREE, LIBRARYTREE)

   416

                self.RefreshAll()

   417

   418

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

   419

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

   420

   421

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

   422

   423

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

   424

   425

    def RefreshTitle(self):

   426

        name = _("Beremiz")

   427

        if self.PluginRoot is not None:

   428

            projectname = self.PluginRoot.GetProjectName()

   429

            if self.PluginRoot.PlugTestModified():

   430

                projectname = "~%s~" % projectname

   431

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

   432

        else:

   433

            self.SetTitle(name)

   434

   435

    def StartLocalRuntime(self, taskbaricon = True):

   436

        if self.local_runtime is None or self.local_runtime.finished:

   437

            # create temporary directory for runtime working directory

   438

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   439

            # choose an arbitrary random port for runtime

   440

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

   441

            # launch local runtime

   442

            self.local_runtime = ProcessLogger(self.Log,

   443

                                               "\"%s\" \"%s\" -p %s -i localhost %s %s"%(sys.executable,

   444

                                                           Bpath("Beremiz_service.py"),

   445

                                                           self.runtime_port,

   446

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

   447

                                                           self.local_runtime_tmpdir),

   448

                                                           no_gui=False)

   449

            self.local_runtime.spin(timeout=500, keyword = "working", kill_it = False)

   450

        return self.runtime_port

   451

   452

    def KillLocalRuntime(self):

   453

        if self.local_runtime is not None:

   454

            # shutdown local runtime

   455

            self.local_runtime.kill(gently=False)

   456

            # clear temp dir

   457

            shutil.rmtree(self.local_runtime_tmpdir)

   458

   459

    def OnOpenWidgetInspector(self, evt):

   460

        # Activate the widget inspection tool

   461

        from wx.lib.inspection import InspectionTool

   462

        if not InspectionTool().initialized:

   463

            InspectionTool().Init()

   464

   465

        # Find a widget to be selected in the tree.  Use either the

   466

        # one under the cursor, if any, or this frame.

   467

        wnd = wx.FindWindowAtPointer()

   468

        if not wnd:

   469

            wnd = self

   470

        InspectionTool().Show(wnd, True)

   471

   472

    def OnLogConsoleDClick(self, event):

   473

        wx.CallAfter(self.SearchLineForError)

   474

        event.Skip()

   475

   476

    def SearchLineForError(self):

   477

        if self.PluginRoot is not None:

   478

            text = self.LogConsole.GetRange(0, self.LogConsole.GetInsertionPoint())

   479

            line = self.LogConsole.GetLineText(len(text.splitlines()) - 1)

   480

            result = MATIEC_ERROR_MODEL.match(line)

   481

            if result is not None:

   482

                first_line, first_column, last_line, last_column, error = result.groups()

   483

                infos = self.PluginRoot.ShowError(self.Log,

   484

                                                  (int(first_line), int(first_column)), 

   485

                                                  (int(last_line), int(last_column)))

   486

   487

    def OnCloseFrame(self, event):

   488

        if self.PluginRoot is not None:

   489

            if self.PluginRoot.ProjectTestModified():

   490

                dialog = wx.MessageDialog(self,

   491

                                          _("Save changes ?"),

   492

                                          _("Close Application"), 

   493

                                          wx.YES_NO|wx.CANCEL|wx.ICON_QUESTION)

   494

                answer = dialog.ShowModal()

   495

                dialog.Destroy()

   496

                if answer == wx.ID_YES: