Docview and IDE patch from Morag Hua with fix for bug #1217890

"Closing view crashes Python" plus some new features:

    New feature added to the IDE is 'Extensions'.  Under
    Tools|Options|Extensions, you can add calls to external programs.
    For example you can add a "Notepad" extension (under windows) that
    will exec Notepad on the currently open file.  A new "Notepad"
    menu item will appear under the Tools menu.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@34638 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

wxPython/samples/ide/activegrid/tool/AbstractEditor.py

@@ -86,11 +86,15 @@ class CanvasView(wx.lib.docview.View):
 
 
     def OnFocus(self, event):
-        self.SetFocus()
         self.FocusColorPropertyShape(True)
         event.Skip()
 
 
+    def FocusOnClick(self, event):
+        self.SetFocus()
+        event.Skip()
+
+
     def OnKillFocus(self, event):
         self.FocusColorPropertyShape(False)
         event.Skip()
@@ -129,12 +133,12 @@ class CanvasView(wx.lib.docview.View):
         wx.EVT_KEY_DOWN(self._canvas, self.OnKeyPressed)
         
         # need this otherwise mouse clicks don't set focus to this view
-        wx.EVT_LEFT_DOWN(self._canvas, self.OnFocus)
-        wx.EVT_LEFT_DCLICK(self._canvas, self.OnFocus)
-        wx.EVT_RIGHT_DOWN(self._canvas, self.OnFocus)
-        wx.EVT_RIGHT_DCLICK(self._canvas, self.OnFocus)
-        wx.EVT_MIDDLE_DOWN(self._canvas, self.OnFocus)
-        wx.EVT_MIDDLE_DCLICK(self._canvas, self.OnFocus)
+        wx.EVT_LEFT_DOWN(self._canvas, self.FocusOnClick)
+        wx.EVT_LEFT_DCLICK(self._canvas, self.FocusOnClick)
+        wx.EVT_RIGHT_DOWN(self._canvas, self.FocusOnClick)
+        wx.EVT_RIGHT_DCLICK(self._canvas, self.FocusOnClick)
+        wx.EVT_MIDDLE_DOWN(self._canvas, self.FocusOnClick)
+        wx.EVT_MIDDLE_DCLICK(self._canvas, self.FocusOnClick)
         
         wx.EVT_KILL_FOCUS(self._canvas, self.OnKillFocus)
         wx.EVT_SET_FOCUS(self._canvas, self.OnFocus)
@@ -397,7 +401,7 @@ class CanvasView(wx.lib.docview.View):
             shape.SetBrush(brush)
         if text:
             shape.AddText(text)
-        shape.SetShadowMode(ogl.SHADOW_RIGHT)
+        shape.SetShadowMode(ogl.SHADOW_NONE)
         self._diagram.AddShape(shape)
         shape.Show(True)
         if not eventHandler:
@@ -417,9 +421,28 @@ class CanvasView(wx.lib.docview.View):
 
         if shape:
             shape.Select(False)
+            for line in shape.GetLines():
+                shape.RemoveLine(line)
+                self._diagram.RemoveShape(line)
+            for obj in self._diagram.GetShapeList():
+                for line in obj.GetLines():
+                    if self.IsShapeContained(shape, line.GetTo()) or self.IsShapeContained(shape, line.GetFrom()):
+                        obj.RemoveLine(line)
+                        self._diagram.RemoveShape(line)
+                    if line == shape:
+                        obj.RemoveLine(line)
+                    
+            shape.RemoveFromCanvas(self._canvas)
             self._diagram.RemoveShape(shape)
-            if isinstance(shape, ogl.CompositeShape):
-                shape.RemoveFromCanvas(self._canvas)
+
+
+    def IsShapeContained(self, parent, shape):
+        if parent == shape:
+            return True
+        elif shape.GetParent():
+            return self.IsShapeContained(parent, shape.GetParent())
+            
+        return False
 
 
     def UpdateShape(self, model):

wxPython/samples/ide/activegrid/tool/DebuggerHarness.py

@@ -378,7 +378,8 @@ class DebuggerHarness(object):
         sys.stdout = output
         sys.stderr = output
         try:
-            exec command in frame.f_globals, frame.f_locals
+            code = compile(command, '<string>', 'single')
+            exec code in frame.f_globals, frame.f_locals
             return output.getvalue()
             sys.stdout = out
             sys.stderr = err        

wxPython/samples/ide/activegrid/tool/DebuggerService.py

@@ -41,7 +41,7 @@ import pickle
 import DebuggerHarness
 import traceback
 import StringIO
-
+import UICommon
 if wx.Platform == '__WXMSW__':
     try:
         import win32api
@@ -132,8 +132,7 @@ import  wx.lib.newevent
 class Executor:
     
     def GetPythonExecutablePath():
-        config = wx.ConfigBase_Get()
-        path = config.Read("ActiveGridPythonLocation")
+        path = UICommon.GetPythonExecPath()
         if path:
             return path
         wx.MessageBox(_("To proceed I need to know the location of the python.exe you would like to use.\nTo set this, go to Tools-->Options and use the 'Python' tab to enter a value.\n"), _("Python Executable Location Unknown"))
@@ -149,24 +148,29 @@ class Executor:
         path = Executor.GetPythonExecutablePath()
         self._cmd = '"' + path + '" -u \"' + fileName + '\"'
         #Better way to do this? Quotes needed for windows file paths.
+        def spaceAndQuote(text):
+            if text.startswith("\"") and text.endswith("\""):
+                return  ' ' + text
+            else:
+                return ' \"' + text + '\"'
         if(arg1 != None):
-            self._cmd += ' \"' + arg1 + '\"'
+            self._cmd += spaceAndQuote(arg1)
         if(arg2 != None):
-            self._cmd += ' \"' + arg2 + '\"'
+            self._cmd += spaceAndQuote(arg2)
         if(arg3 != None):
-            self._cmd += ' \"' + arg3 + '\"'
+            self._cmd += spaceAndQuote(arg3)
         if(arg4 != None):
-            self._cmd += ' \"' + arg4 + '\"'
+            self._cmd += spaceAndQuote(arg4)
         if(arg5 != None):
-            self._cmd += ' \"' + arg5 + '\"'
+            self._cmd += spaceAndQuote(arg5)
         if(arg6 != None):
-            self._cmd += ' \"' + arg6 + '\"'
+            self._cmd += spaceAndQuote(arg6)
         if(arg7 != None):
-            self._cmd += ' \"' + arg7 + '\"'
+            self._cmd += spaceAndQuote(arg7)
         if(arg8 != None):
-            self._cmd += ' \"' + arg8 + '\"'
+            self._cmd += spaceAndQuote(arg8)
         if(arg9 != None):
-            self._cmd += ' \"' + arg9 + '\"'
+            self._cmd += spaceAndQuote(arg9)
         
         self._stdOutReader = None
         self._stdErrReader = None
@@ -621,7 +625,7 @@ class DebugCommandUI(wx.Panel):
         self._tb.EnableTool(self.BREAK_INTO_DEBUGGER_ID, False)
         self._tb.EnableTool(self.KILL_PROCESS_ID, False)
 
-    def SynchCurrentLine(self, filename, lineNum):
+    def SynchCurrentLine(self, filename, lineNum, noArrow=False):
         # FACTOR THIS INTO DocManager
         self.DeleteCurrentLineMarkers()
         
@@ -651,8 +655,9 @@ class DebugCommandUI(wx.Panel):
             foundView.Activate()
             foundView.GotoLine(lineNum)
             startPos = foundView.PositionFromLine(lineNum)
-                
-        foundView.GetCtrl().MarkerAdd(lineNum -1, CodeEditor.CodeCtrl.CURRENT_LINE_MARKER_NUM)
+            
+        if not noArrow:        
+            foundView.GetCtrl().MarkerAdd(lineNum -1, CodeEditor.CodeCtrl.CURRENT_LINE_MARKER_NUM)
 
     def DeleteCurrentLineMarkers(self):
         openDocs = wx.GetApp().GetDocumentManager().GetDocuments()
@@ -803,7 +808,7 @@ class BreakpointsUI(wx.Panel):
             list = self._bpListCtrl
             fileName = list.GetItem(self.currentItem, 2).GetText()
             lineNumber = list.GetItem(self.currentItem, 1).GetText()
-            self._ui.SynchCurrentLine( fileName, int(lineNumber) )  
+            self._ui.SynchCurrentLine( fileName, int(lineNumber) , noArrow=True)  
 
     def ClearBreakPoint(self, event):
         if self.currentItem >= 0:
@@ -1810,7 +1815,7 @@ class DebuggerService(Service.Service):
         wsService = wx.GetApp().GetService(WebServerService.WebServerService)
         fileName, args = wsService.StopAndPrepareToDebug()
         try:
-            page = DebugCommandUI(Service.ServiceView.bottomTab, -1, str(fileName), self)
+            page = DebugCommandUI(Service.ServiceView.bottomTab, -1, fileName, self)
             count = Service.ServiceView.bottomTab.GetPageCount()
             Service.ServiceView.bottomTab.AddPage(page, _("Debugging: Internal WebServer"))
             Service.ServiceView.bottomTab.SetSelection(count)
@@ -2124,7 +2129,7 @@ class CommandPropertiesDialog(wx.Dialog):
         flexGridSizer.Add(self._pythonPathEntry, 1, wx.EXPAND)
         flexGridSizer.Add(wx.StaticText(parent, -1, ""), 0)
         flexGridSizer.Add(wx.StaticText(parent, -1, ""), 0)
-        if debugging:
+        if debugging and _WINDOWS:
             self._postpendCheckBox = wx.CheckBox(self, -1, postpendStaticText)
             checked = bool(config.ReadInt("PythonPathPostpend", 1))
             self._postpendCheckBox.SetValue(checked)

wxPython/samples/ide/activegrid/tool/ExtensionService.py

@@ -0,0 +1,387 @@
+#----------------------------------------------------------------------------
+# Name:         ExtensionService.py
+# Purpose:      Extension Service for IDE
+#
+# Author:       Peter Yared
+#
+# Created:      5/23/05
+# CVS-ID:       $ID:$
+# Copyright:    (c) 2005 ActiveGrid, Inc.
+# License:      wxWindows License
+#----------------------------------------------------------------------------
+
+import wx
+import wx.lib.pydocview
+import MessageService
+import os
+import os.path
+import pickle
+
+_ = wx.GetTranslation
+
+
+SPACE = 10
+HALF_SPACE = 5
+
+
+EXTENSIONS_CONFIG_STRING = "Extensions"
+
+
+
+# TODO: Redo extensions menu on OK, or provide alert that it won't happen until restart
+
+
+#----------------------------------------------------------------------------
+# Classes
+#----------------------------------------------------------------------------
+
+class Extension:
+    
+
+    def __init__(self, menuItemName):
+        self.menuItemName = menuItemName
+        self.id = 0
+        self.menuItemDesc = ''
+        self.command = ''
+        self.commandPreArgs = ''
+        self.commandPostArgs = ''
+        self.fileExt = None
+
+
+class ExtensionService(wx.lib.pydocview.DocService):
+
+
+    def __init__(self):
+        self.LoadExtensions()
+
+
+    def LoadExtensions(self):
+        config = wx.ConfigBase_Get()
+        pickledExtensions = config.Read(EXTENSIONS_CONFIG_STRING)
+        if pickledExtensions:
+            try:
+                self._extensions = pickle.loads(pickledExtensions.encode('ascii'))
+            except:
+                tp, val, tb = sys.exc_info()
+                traceback.print_exception(tp,val,tb)
+                self._extensions = []
+        else:
+            self._extensions = []
+        
+
+    def SaveExtensions(self):
+        config = wx.ConfigBase_Get()
+        config.Write(EXTENSIONS_CONFIG_STRING, pickle.dumps(self._extensions))
+
+
+    def GetExtensions(self):
+        return self._extensions
+
+
+    def SetExtensions(self, extensions):
+        self._extensions = extensions
+
+
+    def InstallControls(self, frame, menuBar = None, toolBar = None, statusBar = None, document = None):
+        toolsMenuIndex = menuBar.FindMenu(_("&Tools"))
+        if toolsMenuIndex > -1:
+            toolsMenu = menuBar.GetMenu(toolsMenuIndex)
+        else:
+            toolsMenu = wx.Menu()
+        
+        if self._extensions:
+            if toolsMenu.GetMenuItems():
+                toolsMenu.AppendSeparator()            
+            for ext in self._extensions:
+                # Append a tool menu item for each extension
+                ext.id = wx.NewId()
+                toolsMenu.Append(ext.id, ext.menuItemName)
+                wx.EVT_MENU(frame, ext.id, frame.ProcessEvent)
+                wx.EVT_UPDATE_UI(frame, ext.id, frame.ProcessUpdateUIEvent)
+
+        if toolsMenuIndex == -1:
+            formatMenuIndex = menuBar.FindMenu(_("&Format"))
+            menuBar.Insert(formatMenuIndex + 1, toolsMenu, _("&Tools"))
+
+    def ProcessEvent(self, event):
+        id = event.GetId()
+        for extension in self._extensions:
+            if id == extension.id:
+                self.OnExecuteExtension(extension)
+                return True
+        return False
+
+
+    def ProcessUpdateUIEvent(self, event):
+        id = event.GetId()
+        for extension in self._extensions:
+            if id == extension.id:
+                if extension.fileExt:
+                    doc = wx.GetApp().GetDocumentManager().GetCurrentDocument()
+                    if doc and '*' in extension.fileExt:
+                        event.Enable(True)
+                        return True
+                    if doc:
+                        for fileExt in extension.fileExt:
+                            if fileExt in doc.GetDocumentTemplate().GetFileFilter():
+                                event.Enable(True)
+                                return True
+                    event.Enable(False)
+                    return False
+        return False
+
+
+    def OnExecuteExtension(self, extension):
+        if extension.fileExt:
+            doc = wx.GetApp().GetDocumentManager().GetCurrentDocument()
+            if not doc:
+                return
+            filename = doc.GetFilename()
+            ext = os.path.splitext(filename)[1]
+            if not '*' in extension.fileExt:
+                if not ext or ext[1:] not in extension.fileExt:
+                    return
+            cmds = [extension.command]
+            if extension.commandPreArgs:
+                cmds.append(extension.commandPreArgs)
+            cmds.append(filename)
+            if extension.commandPostArgs:
+                cmds.append(extension.commandPostArgs)
+            os.spawnv(os.P_NOWAIT, extension.command, cmds)
+                      
+        else:
+            cmd = extension.command
+            if extension.commandPreArgs:
+                cmd = cmd + ' ' + extension.commandPreArgs
+            if extension.commandPostArgs:
+                cmd = cmd + ' ' + extension.commandPostArgs
+            f = os.popen(cmd)
+            messageService = wx.GetApp().GetService(MessageService.MessageService)
+            messageService.ShowWindow()
+            view = messageService.GetView()
+            for line in f.readlines():
+                view.AddLines(line)
+            view.GetControl().EnsureCaretVisible()
+            f.close()
+            
+
+class ExtensionOptionsPanel(wx.Panel):
+
+
+    def __init__(self, parent, id):
+        wx.Panel.__init__(self, parent, id)
+        
+        extOptionsPanelBorderSizer = wx.BoxSizer(wx.HORIZONTAL)
+        
+        extOptionsPanelSizer = wx.FlexGridSizer(cols=2, hgap=SPACE, vgap=HALF_SPACE)
+        
+        extCtrlSizer = wx.BoxSizer(wx.VERTICAL)
+        extCtrlSizer.Add(wx.StaticText(self, -1, _("Extensions:")), 0)
+        self._extListBox = wx.ListBox(self, -1, size=(-1,185), style=wx.LB_SINGLE)
+        self.Bind(wx.EVT_LISTBOX, self.OnListBoxSelect, self._extListBox)
+        extCtrlSizer.Add(self._extListBox, 1, wx.TOP | wx.BOTTOM | wx.EXPAND, SPACE)        
+        buttonSizer = wx.GridSizer(rows=1, hgap=10, vgap=5)
+        self._moveUpButton = wx.Button(self, -1, _("Move Up"))
+        self.Bind(wx.EVT_BUTTON, self.OnMoveUp, self._moveUpButton)
+        buttonSizer.Add(self._moveUpButton, 0)
+        self._moveDownButton = wx.Button(self, -1, _("Move Down"))
+        self.Bind(wx.EVT_BUTTON, self.OnMoveDown, self._moveDownButton)
+        buttonSizer.Add(self._moveDownButton, 0)
+        extCtrlSizer.Add(buttonSizer, 0, wx.ALIGN_CENTER | wx.BOTTOM, HALF_SPACE)
+        buttonSizer = wx.GridSizer(rows=1, hgap=10, vgap=5)
+        self._addButton = wx.Button(self, -1, _("Add"))
+        self.Bind(wx.EVT_BUTTON, self.OnAdd, self._addButton)
+        buttonSizer.Add(self._addButton, 0)
+        self._deleteButton = wx.Button(self, wx.ID_DELETE)
+        self.Bind(wx.EVT_BUTTON, self.OnDelete, self._deleteButton)
+        buttonSizer.Add(self._deleteButton, 0)
+        extCtrlSizer.Add(buttonSizer, 0, wx.ALIGN_CENTER)
+        extOptionsPanelSizer.Add(extCtrlSizer, 0)
+
+        self._extDetailPanel = wx.Panel(self)
+        staticBox = wx.StaticBox(self._extDetailPanel, label=_("Selected Extension"))
+        staticBoxSizer = wx.StaticBoxSizer(staticBox)
+        self._extDetailPanel.SetSizer(staticBoxSizer)
+        extDetailSizer = wx.FlexGridSizer(cols=1, hgap=5, vgap=3)
+        staticBoxSizer.AddSizer(extDetailSizer, 0, wx.ALL, 5)
+
+        extDetailSizer.Add(wx.StaticText(self._extDetailPanel, -1, _("Menu Item Name:")))
+        self._menuItemNameTextCtrl = wx.TextCtrl(self._extDetailPanel, -1, size = (-1, -1))
+        extDetailSizer.Add(self._menuItemNameTextCtrl, 1, wx.EXPAND)
+        self.Bind(wx.EVT_TEXT, self.SaveCurrentItem, self._menuItemNameTextCtrl)        
+
+        extDetailSizer.Add(wx.StaticText(self._extDetailPanel, -1, _("Menu Item Description:")))
+        self._menuItemDescTextCtrl = wx.TextCtrl(self._extDetailPanel, -1, size = (-1, -1))
+        extDetailSizer.Add(self._menuItemDescTextCtrl, 1, wx.EXPAND)
+
+        extDetailSizer.Add(wx.StaticText(self._extDetailPanel, -1, _("Command Path:")))
+        self._commandTextCtrl = wx.TextCtrl(self._extDetailPanel, -1, size = (-1, -1))        
+        findFileButton = wx.Button(self._extDetailPanel, -1, _("Browse..."))
+        def OnBrowseButton(event):
+            fileDlg = wx.FileDialog(self, _("Choose an Executable:"), style=wx.OPEN | wx.HIDE_READONLY)
+            path = self._commandTextCtrl.GetValue()
+            if path:
+                fileDlg.SetPath(path)
+            if fileDlg.ShowModal() == wx.ID_OK:
+                self._commandTextCtrl.SetValue(fileDlg.GetPath())
+                self._commandTextCtrl.SetInsertionPointEnd()
+            fileDlg.Destroy()
+        wx.EVT_BUTTON(findFileButton, -1, OnBrowseButton)
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        hsizer.Add(self._commandTextCtrl, 1, wx.EXPAND)
+        hsizer.Add(findFileButton, 0, wx.LEFT, HALF_SPACE)
+        extDetailSizer.Add(hsizer, 0)
+
+        extDetailSizer.Add(wx.StaticText(self._extDetailPanel, -1, _("Command Pre Arguments:")))
+        self._commandPreArgsTextCtrl = wx.TextCtrl(self._extDetailPanel, -1, size = (-1, -1))
+        extDetailSizer.Add(self._commandPreArgsTextCtrl, 1, wx.EXPAND)
+
+        extDetailSizer.Add(wx.StaticText(self._extDetailPanel, -1, _("Command Post Arguments:")))
+        self._commandPostArgsTextCtrl = wx.TextCtrl(self._extDetailPanel, -1, size = (-1, -1))
+        extDetailSizer.Add(self._commandPostArgsTextCtrl, 1, wx.EXPAND)
+
+        extDetailSizer.Add(wx.StaticText(self._extDetailPanel, -1, _("File Extensions (Comma Separated):")))
+        self._fileExtTextCtrl = wx.TextCtrl(self._extDetailPanel, -1, size = (-1, -1))
+        self._fileExtTextCtrl.SetToolTipString(_("""For example: "txt, text" or "*" for all files"""))
+        extDetailSizer.Add(self._fileExtTextCtrl, 1, wx.EXPAND)
+
+        extOptionsPanelSizer.Add(self._extDetailPanel, 0)
+
+        extOptionsPanelBorderSizer.Add(extOptionsPanelSizer, 0, wx.ALL | wx.EXPAND, SPACE)
+        self.SetSizer(extOptionsPanelBorderSizer)
+        self.Layout()
+        parent.AddPage(self, _("Extensions"))
+        
+        if self.PopulateItems():
+            self._extListBox.SetSelection(0)
+        self.OnListBoxSelect(None)
+
+
+    def OnOK(self, optionsDialog):
+        self.SaveCurrentItem()
+        extensionsService = wx.GetApp().GetService(ExtensionService)
+        oldExtensions = extensionsService.GetExtensions()
+        extensionsService.SetExtensions(self._extensions)
+        extensionsService.SaveExtensions()
+        if oldExtensions.__repr__() != self._extensions.__repr__():
+            msgTitle = wx.GetApp().GetAppName()
+            if not msgTitle:
+                msgTitle = _("Document Options")
+            wx.MessageBox(_("Extension changes will not appear until the application is restarted."),
+                          msgTitle,
+                          wx.OK | wx.ICON_INFORMATION,
+                          self.GetParent())
+        
+
+    def PopulateItems(self):
+        extensionsService = wx.GetApp().GetService(ExtensionService)
+        import copy
+        self._extensions = copy.deepcopy(extensionsService.GetExtensions())
+        for extension in self._extensions:
+            self._extListBox.Append(extension.menuItemName, extension)
+        self._currentItem = None
+        self._currentItemIndex = -1
+        return len(self._extensions)
+      
+
+    def OnListBoxSelect(self, event):
+        self.SaveCurrentItem()
+        if not self._extListBox.GetSelections():
+            self._currentItemIndex = -1
+            self._currentItem = None
+            self._deleteButton.Enable(False)
+            self._moveUpButton.Enable(False)
+            self._moveDownButton.Enable(False)
+        else:
+            self._currentItemIndex = self._extListBox.GetSelection()
+            self._currentItem = self._extListBox.GetClientData(self._currentItemIndex)
+            self._deleteButton.Enable()
+            self._moveUpButton.Enable(self._extListBox.GetCount() > 1 and self._currentItemIndex > 0)
+            self._moveDownButton.Enable(self._extListBox.GetCount() > 1 and self._currentItemIndex < self._extListBox.GetCount() - 1)
+        self.LoadItem(self._currentItem)
+
+
+    def SaveCurrentItem(self, event=None):
+        extension = self._currentItem
+        if extension:
+            if extension.menuItemName != self._menuItemNameTextCtrl.GetValue():
+                extension.menuItemName = self._menuItemNameTextCtrl.GetValue()
+                self._extListBox.SetString(self._currentItemIndex, extension.menuItemName)
+            extension.menuItemDesc = self._menuItemDescTextCtrl.GetValue()
+            extension.command = self._commandTextCtrl.GetValue()
+            extension.commandPreArgs = self._commandPreArgsTextCtrl.GetValue()
+            extension.commandPostArgs = self._commandPostArgsTextCtrl.GetValue()
+            fileExt = self._fileExtTextCtrl.GetValue().replace(' ','')
+            if not fileExt:
+                extension.fileExt = None
+            else:
+                extension.fileExt = fileExt.split(',')
+            
+
+    def LoadItem(self, extension):
+        if extension:
+            self._menuItemDescTextCtrl.SetValue(extension.menuItemDesc or '')
+            self._commandTextCtrl.SetValue(extension.command or '')
+            self._commandPreArgsTextCtrl.SetValue(extension.commandPreArgs or '')
+            self._commandPostArgsTextCtrl.SetValue(extension.commandPostArgs or '')
+            if extension.fileExt:
+                self._fileExtTextCtrl.SetValue(extension.fileExt.__repr__()[1:-1].replace("'",""))  # Make the list a string, strip the brakcet on either side
+            else:
+                self._fileExtTextCtrl.SetValue('')
+            self._menuItemNameTextCtrl.SetValue(extension.menuItemName or '')  # Do the name last since it triggers the write event that updates the entire item
+            self._extDetailPanel.Enable()
+        else:
+            self._menuItemNameTextCtrl.SetValue('')
+            self._menuItemDescTextCtrl.SetValue('')
+            self._commandTextCtrl.SetValue('')
+            self._commandPreArgsTextCtrl.SetValue('')
+            self._commandPostArgsTextCtrl.SetValue('')
+            self._fileExtTextCtrl.SetValue('')
+            self._extDetailPanel.Enable(False)
+            
+      
+    def OnAdd(self, event):
+        self.SaveCurrentItem()
+        extensionNames = map(lambda extension: extension.menuItemName, self._extensions)
+        name = _("Untitled")
+        count = 1
+        while name in extensionNames:
+            count = count + 1
+            name = _("Untitled %s") % count
+        extension = Extension(name)
+        self._extensions.append(extension)
+        self._extListBox.Append(extension.menuItemName, extension)
+        self._extListBox.SetSelection(self._extListBox.GetCount() - 1)
+        self.OnListBoxSelect(None)
+        self._menuItemNameTextCtrl.SetFocus()
+        self._menuItemNameTextCtrl.SetSelection(-1, -1)
+        
+
+    def OnDelete(self, event):
+        self._extListBox.Delete(self._currentItemIndex)
+        self._extensions.remove(self._currentItem)    
+        self._currentItemIndex = min(self._currentItemIndex, self._extListBox.GetCount() - 1)
+        if self._currentItemIndex > -1:
+            self._extListBox.SetSelection(self._currentItemIndex)
+        self._currentItem = None  # Don't update it since it no longer exists
+        self.OnListBoxSelect(None)
+
+
+    def OnMoveUp(self, event):
+        itemAboveString = self._extListBox.GetString(self._currentItemIndex - 1)
+        itemAboveData = self._extListBox.GetClientData(self._currentItemIndex - 1)
+        self._extListBox.Delete(self._currentItemIndex - 1)
+        self._extListBox.Insert(itemAboveString, self._currentItemIndex)
+        self._extListBox.SetClientData(self._currentItemIndex, itemAboveData)
+        self._currentItemIndex = self._currentItemIndex - 1
+        self.OnListBoxSelect(None) # Reset buttons
+
+
+    def OnMoveDown(self, event):
+        itemBelowString = self._extListBox.GetString(self._currentItemIndex + 1)
+        itemBelowData = self._extListBox.GetClientData(self._currentItemIndex + 1)
+        self._extListBox.Delete(self._currentItemIndex + 1)
+        self._extListBox.Insert(itemBelowString, self._currentItemIndex)
+        self._extListBox.SetClientData(self._currentItemIndex, itemBelowData)
+        self._currentItemIndex = self._currentItemIndex + 1
+        self.OnListBoxSelect(None) # Reset buttons

wxPython/samples/ide/activegrid/tool/IDE.py

@@ -81,6 +81,7 @@ class IDEApplication(wx.lib.pydocview.DocApp):
         import DebuggerService
         import AboutDialog
         import SVNService
+        import ExtensionService
                     
         if not ACTIVEGRID_BASE_IDE:
             import DataModelEditor
@@ -304,6 +305,7 @@ class IDEApplication(wx.lib.pydocview.DocApp):
             deploymentService   = self.InstallService(DeploymentService.DeploymentService())
             dataModelService    = self.InstallService(DataModelEditor.DataModelService())
             welcomeService      = self.InstallService(WelcomeService.WelcomeService())
+        extensionService        = self.InstallService(ExtensionService.ExtensionService())
         optionsService          = self.InstallService(wx.lib.pydocview.DocOptionsService(supportedModes=wx.lib.docview.DOC_MDI))
         aboutService            = self.InstallService(wx.lib.pydocview.AboutService(AboutDialog.AboutDialog))
         svnService              = self.InstallService(SVNService.SVNService())
@@ -326,6 +328,7 @@ class IDEApplication(wx.lib.pydocview.DocApp):
         optionsService.AddOptionsPanel(STCTextEditor.TextOptionsPanel)
         optionsService.AddOptionsPanel(HtmlEditor.HtmlOptionsPanel)
         optionsService.AddOptionsPanel(SVNService.SVNOptionsPanel)
+        optionsService.AddOptionsPanel(ExtensionService.ExtensionOptionsPanel)
 
         filePropertiesService.AddCustomEventHandler(projectService)
 
@@ -374,7 +377,7 @@ class IDEApplication(wx.lib.pydocview.DocApp):
             if os.path.exists(tips_path):
                 wx.CallAfter(self.ShowTip, docManager.FindSuitableParent(), wx.CreateFileTipProvider(tips_path, 0))
 
-        wx.UpdateUIEvent.SetUpdateInterval(200)  # Overhead of updating menus was too much.  Change to update every 200 milliseconds.
+        wx.UpdateUIEvent.SetUpdateInterval(400)  # Overhead of updating menus was too much.  Change to update every 400 milliseconds.
         
         return True
 

wxPython/samples/ide/activegrid/tool/ProjectEditor.py

@@ -20,7 +20,7 @@ from wxPython.lib.rcsizer import RowColSizer
 import time
 import Service
 import sys
-import activegrid.util.objutils
+import activegrid.util.xmlutils
 import UICommon
 import Wizard
 import SVNService
@@ -49,10 +49,10 @@ HALF_SPACE = 5
 #----------------------------------------------------------------------------
 
 def load(fileObject):
-    return activegrid.util.objutils.defaultLoad(fileObject)
+    return activegrid.util.xmlutils.defaultLoad(fileObject, knownTypes={"projectmodel" : ProjectModel})
 
 def save(fileObject, projectModel):
-    activegrid.util.objutils.defaultSave(fileObject, projectModel, prettyPrint=True)
+    activegrid.util.xmlutils.defaultSave(fileObject, projectModel, prettyPrint=True, knownTypes={"projectmodel" : ProjectModel})
 
 
 #----------------------------------------------------------------------------
@@ -1055,7 +1055,8 @@ class ProjectView(wx.lib.docview.View):
             descr = template.GetDescription() + _(" (") + template.GetFileFilter() + _(")")
             choices.append(descr)
             allfilter = allfilter + template.GetFileFilter()
-        choices.insert(0, _("All (%s)") % allfilter)
+        choices.insert(0, _("All (%s)") % allfilter)  # first item
+        choices.append(_("Any (*.*)"))  # last item
         filterChoice = wx.Choice(frame, -1, size=(250, -1), choices=choices)
         filterChoice.SetSelection(0)
         filterChoice.SetToolTipString(_("Select file type filter."))
@@ -1112,7 +1113,8 @@ class ProjectView(wx.lib.docview.View):
                 paths = []
                 
                 index = filterChoice.GetSelection()
-                if index:
+                lastIndex = filterChoice.GetCount()-1
+                if index and index != lastIndex:  # if not All or Any
                     template = visibleTemplates[index-1]
 
                 # do search in files on disk
@@ -1121,7 +1123,7 @@ class ProjectView(wx.lib.docview.View):
                         break
                         
                     for name in files:
-                        if index == 0:  # all
+                        if index == 0:  # All
                             for template in visibleTemplates:
                                 if template.FileMatchesTemplate(name):
                                     filename = os.path.join(root, name)
@@ -1132,6 +1134,11 @@ class ProjectView(wx.lib.docview.View):
 
                                     paths.append(filename)
                                     break
+                        elif index == lastIndex:  # Any
+                            filename = os.path.join(root, name)
+                            # if already in project, don't add it, otherwise undo will remove it from project even though it was already in it.
+                            if not doc.IsFileInProject(filename):
+                                paths.append(filename)                    
                         else:  # use selected filter
                             if template.FileMatchesTemplate(name):
                                 filename = os.path.join(root, name)

wxPython/samples/ide/activegrid/tool/UICommon.py

@@ -14,6 +14,7 @@ import os
 import os.path
 import wx
 import ProjectEditor
+import activegrid.util as utillib
 _ = wx.GetTranslation
 
 def CreateDirectoryControl( parent, fileLabel, dirLabel, fileExtension, startingName="", startingDirectory=""):
@@ -117,4 +118,11 @@ def PluralName(name):
         return name[0:-1] + 'ies'
     else:
         return name + 's'
-           
+           
+def GetPythonExecPath():
+    pythonExecPath = wx.ConfigBase_Get().Read("ActiveGridPythonLocation")
+    if not pythonExecPath:
+        pythonExecPath = utillib.pythonExecPath
+    return pythonExecPath
+    
+