]> git.saurik.com Git - wxWidgets.git/blob - wxPython/samples/ide/activegrid/tool/ProjectEditor.py
Applied patch [ 1284335 ] doc update for wxString::operator[]
[wxWidgets.git] / wxPython / samples / ide / activegrid / tool / ProjectEditor.py
1 #----------------------------------------------------------------------------
2 # Name: ProjectEditor.py
3 # Purpose: IDE-style Project Editor for wx.lib.pydocview
4 #
5 # Author: Peter Yared, Morgan Hua
6 #
7 # Created: 8/15/03
8 # CVS-ID: $Id$
9 # Copyright: (c) 2003, 2004, 2005 ActiveGrid, Inc.
10 # License: wxWindows License
11 #----------------------------------------------------------------------------
12
13 import wx.lib.docview
14 import wx.lib.pydocview
15 import types
16 import os
17 import os.path
18 import wx
19 from wxPython.lib.rcsizer import RowColSizer
20 import time
21 import Service
22 import sys
23 import activegrid.util.xmlutils
24 import UICommon
25 import Wizard
26 import SVNService
27 from IDE import ACTIVEGRID_BASE_IDE
28 if not ACTIVEGRID_BASE_IDE:
29 import ProcessModelEditor
30 from SVNService import SVN_INSTALLED
31
32 _ = wx.GetTranslation
33
34 if wx.Platform == '__WXMSW__':
35 _WINDOWS = True
36 else:
37 _WINDOWS = False
38
39
40 #----------------------------------------------------------------------------
41 # Constants
42 #----------------------------------------------------------------------------
43 SPACE = 10
44 HALF_SPACE = 5
45
46
47 #----------------------------------------------------------------------------
48 # XML Marshalling Methods
49 #----------------------------------------------------------------------------
50
51 def load(fileObject):
52 return activegrid.util.xmlutils.defaultLoad(fileObject, knownTypes={"projectmodel" : ProjectModel})
53
54 def save(fileObject, projectModel):
55 activegrid.util.xmlutils.defaultSave(fileObject, projectModel, prettyPrint=True, knownTypes={"projectmodel" : ProjectModel})
56
57
58 #----------------------------------------------------------------------------
59 # Classes
60 #----------------------------------------------------------------------------
61
62 class ProjectModel:
63 __xmlname__ = "projectmodel"
64 __xmlrename__ = { "_files":"files"}
65
66
67 def __init__(self):
68 self._files = []
69
70 def initialize(self):
71 pass
72
73
74 class ProjectDocument(wx.lib.docview.Document):
75
76
77 def __init__(self):
78 wx.lib.docview.Document.__init__(self)
79 self._projectModel = ProjectModel()
80
81
82 def GetModel(self):
83 return self._projectModel
84
85
86 def OnCreate(self, path, flags):
87 projectService = wx.GetApp().GetService(ProjectService)
88 if projectService.GetView():
89 # All project documents share the same view.
90 view = projectService.GetView()
91 self.AddView(view)
92
93 if view.GetDocument():
94 # All project documents need to share the same command processor,
95 # to enable redo/undo of cross project document commands
96 cmdProcessor = view.GetDocument().GetCommandProcessor()
97 if cmdProcessor:
98 self.SetCommandProcessor(cmdProcessor)
99 else:
100 view = self.GetDocumentTemplate().CreateView(self, flags)
101 projectService.SetView(view)
102
103
104 return view
105
106
107 def LoadObject(self, fileObject):
108 self._projectModel = activegrid.tool.ProjectEditor.load(fileObject)
109 self._projectModel._files = self.RelativeToAbsPath(self._projectModel._files)
110 return True
111
112
113 def SaveObject(self, fileObject):
114 absPath = self._projectModel._files
115 self._projectModel._files = self.AbsToRelativePath(absPath) # temporarily change it to relative paths for saving
116 activegrid.tool.ProjectEditor.save(fileObject, self._projectModel)
117 self._projectModel._files = absPath # swap it back to absolute path
118 return True
119
120
121 def AbsToRelativePath(self, paths):
122 curPath = os.path.dirname(self.GetFilename())
123 curPathLen = len(curPath)
124
125 newFilePaths = []
126 for path in paths:
127 if path.startswith(curPath):
128 path = "." + path[curPathLen:] # use relative path
129 if os.sep != '/':
130 path = path.replace(os.sep, '/', -1) # always save out with '/' as path separator for cross-platform compatibility.
131 else:
132 pass # use absolute path
133 newFilePaths.append(path)
134 return newFilePaths
135
136
137 def RelativeToAbsPath(self, paths):
138 newFilePaths = []
139 for path in paths:
140 if path.startswith("."): # relative to project file
141 curPath = os.path.dirname(self.GetFilename())
142 path = os.path.normpath(os.path.join(curPath, path))
143 newFilePaths.append(path)
144 return newFilePaths
145
146
147 def OnOpenDocument(self, filename):
148 view = self.GetFirstView()
149 frame = view.GetFrame()
150
151 if not os.path.exists(filename):
152 wx.GetApp().CloseSplash()
153 msgTitle = wx.GetApp().GetAppName()
154 if not msgTitle:
155 msgTitle = _("File Error")
156 wx.MessageBox(_("Could not find '%s'.") % filename,
157 msgTitle,
158 wx.OK | wx.ICON_EXCLAMATION | wx.STAY_ON_TOP,
159 frame)
160 return True # if we return False, the Project View is destroyed, Service windows shouldn't be destroyed
161
162 fileObject = file(filename, 'r')
163 try:
164 self.LoadObject(fileObject)
165 except:
166 wx.GetApp().CloseSplash()
167 msgTitle = wx.GetApp().GetAppName()
168 if not msgTitle:
169 msgTitle = _("File Error")
170 wx.MessageBox(_("Could not open '%s'. %s") % (wx.lib.docview.FileNameFromPath(filename), sys.exc_value),
171 msgTitle,
172 wx.OK | wx.ICON_EXCLAMATION | wx.STAY_ON_TOP,
173 frame)
174 return True # if we return False, the Project View is destroyed, Service windows shouldn't be destroyed
175
176 self.Modify(False)
177 self.SetFilename(filename, True)
178 view.AddProjectToView(self)
179 self.SetDocumentModificationDate()
180 self.UpdateAllViews()
181 self._savedYet = True
182 view.Activate(True)
183 return True
184
185
186 def AddFile(self, file):
187 return self.AddFiles([file])
188
189
190 def AddFiles(self, files):
191 notAlreadyThereFiles = filter(lambda x: x not in self._projectModel._files, files) # Filter to the files that are not already in the project
192 if len(notAlreadyThereFiles) == 0:
193 self.UpdateAllViews(hint = ("select", self, files))
194 return False
195 else:
196 self._projectModel._files = self._projectModel._files + notAlreadyThereFiles
197 self.UpdateAllViews(hint = ("add", self, notAlreadyThereFiles))
198 self.Modify(True)
199 return True
200
201
202 def RemoveFile(self, file):
203 return self.RemoveFiles([file])
204
205
206 def RemoveFiles(self, files):
207 for file in files:
208 self._projectModel._files.remove(file)
209 self.UpdateAllViews(hint = ("remove", self, files))
210 self.Modify(True)
211 return True
212
213
214 def RenameFile(self, oldFile, newFile, isProject = False):
215 try:
216 if oldFile == newFile:
217 return False
218
219 # projects don't have to exist yet, so not required to rename old file,
220 # but files must exist, so we'll try to rename and allow exceptions to occur if can't.
221 if not isProject or (isProject and os.path.exists(oldFile)):
222 os.rename(oldFile, newFile)
223
224 if isProject:
225 documents = self.GetDocumentManager().GetDocuments()
226 for document in documents:
227 if os.path.normcase(document.GetFilename()) == os.path.normcase(oldFile): # If the renamed document is open, update it
228 document.SetFilename(newFile)
229 document.SetTitle(wx.lib.docview.FileNameFromPath(newFile))
230 document.UpdateAllViews(hint = ("rename", document, newFile))
231 else:
232 self.RemoveFile(oldFile)
233 self.AddFile(newFile)
234 documents = self.GetDocumentManager().GetDocuments()
235 for document in documents:
236 if os.path.normcase(document.GetFilename()) == os.path.normcase(oldFile): # If the renamed document is open, update it
237 document.SetFilename(newFile, notifyViews = True)
238 document.UpdateAllViews(hint = ("rename", document, newFile))
239 return True
240 except OSError, (code, message):
241 msgTitle = wx.GetApp().GetAppName()
242 if not msgTitle:
243 msgTitle = _("File Error")
244 wx.MessageBox("Could not rename '%s'. '%s'" % (wx.lib.docview.FileNameFromPath(oldFile), message),
245 msgTitle,
246 wx.OK | wx.ICON_EXCLAMATION,
247 self.GetFirstView().GetFrame())
248 return False
249
250
251 def GetFiles(self):
252 return self._projectModel._files
253
254
255 def IsFileInProject(self, filename):
256 return filename in self.GetFiles()
257
258
259 class NewProjectWizard(Wizard.BaseWizard):
260
261 WIZTITLE = _("New Project Wizard")
262
263 def __init__(self, parent):
264 self._parent = parent
265 self._fullProjectPath = None
266 Wizard.BaseWizard.__init__(self, parent, self.WIZTITLE)
267 self._projectLocationPage = self.CreateProjectLocation(self)
268 wx.wizard.EVT_WIZARD_PAGE_CHANGING(self, self.GetId(), self.OnWizPageChanging)
269
270
271 def CreateProjectLocation(self,wizard):
272 page = Wizard.TitledWizardPage(wizard, _("Project File Location"))
273
274 page.GetSizer().Add(wx.StaticText(page, -1, _("\nSelect the directory and filename for the project.\n\n")))
275 self._projectName, self._dirCtrl, sizer, self._fileValidation = UICommon.CreateDirectoryControl(page, _("File Name:"), _("Directory:"), _("agp"), startingDirectory=os.getcwd())
276 page.GetSizer().Add(sizer, 1, flag=wx.EXPAND)
277
278 wizard.Layout()
279 wizard.FitToPage(page)
280 return page
281
282
283 def RunWizard(self, existingTables = None, existingRelationships = None):
284 status = wx.wizard.Wizard.RunWizard(self, self._projectLocationPage)
285 if status:
286 docManager = wx.GetApp().GetTopWindow().GetDocumentManager()
287 if os.path.exists(self._fullProjectPath):
288 # What if the document is already open and we're overwriting it?
289 documents = docManager.GetDocuments()
290 for document in documents:
291 if os.path.normcase(document.GetFilename()) == os.path.normcase(self._fullProjectPath): # If the renamed document is open, update it
292 document.DeleteAllViews()
293 break
294 os.remove(self._fullProjectPath)
295
296 for template in docManager.GetTemplates():
297 if template.GetDocumentType() == ProjectDocument:
298 doc = template.CreateDocument(self._fullProjectPath, flags = wx.lib.docview.DOC_NEW)
299 doc.OnSaveDocument(self._fullProjectPath)
300 view = doc.GetFirstView()
301 view.AddProjectToView(doc)
302 break
303
304 self.Destroy()
305 return status
306
307
308 def OnWizPageChanging(self, event):
309 if event.GetDirection(): # It's going forwards
310 if event.GetPage() == self._projectLocationPage:
311 if not self._fileValidation():
312 event.Veto()
313 return
314 self._fullProjectPath = os.path.join(self._dirCtrl.GetValue(),UICommon.MakeNameEndInExtension(self._projectName.GetValue(),'.agp'))
315
316
317
318 def OnShowCreatePages(self):
319 self.Hide()
320 import DataModelEditor
321 requestedPos = self.GetPositionTuple()
322 projectService = wx.GetApp().GetService(ProjectService)
323 projectView = projectService.GetView()
324
325 wiz = DataModelEditor.ImportExportWizard(projectView.GetFrame(), pos=requestedPos)
326 if wiz.RunWizard(dontDestroy=True):
327 self._schemaName.SetValue(wiz.GetSchemaFileName())
328 wiz.Destroy()
329 self.Show(True)
330
331
332 class ProjectTemplate(wx.lib.docview.DocTemplate):
333
334
335 def CreateDocument(self, path, flags):
336 if path:
337 return wx.lib.docview.DocTemplate.CreateDocument(self, path, flags)
338 else:
339 wiz = NewProjectWizard(wx.GetApp().GetTopWindow())
340 wiz.RunWizard()
341 wiz.Destroy()
342 return None # never return the doc, otherwise docview will think it is a new file and rename it
343
344
345 class ProjectAddFilesCommand(wx.lib.docview.Command):
346
347
348 def __init__(self, projectDoc, files):
349 wx.lib.docview.Command.__init__(self, canUndo = True)
350 self._projectDoc = projectDoc
351 self._files = files
352
353
354 def GetName(self):
355 if len(self._files) == 1:
356 return _("Add File %s") % os.path.basename(self._files[0])
357 else:
358 return _("Add Files")
359
360
361 def Do(self):
362 return self._projectDoc.AddFiles(self._files)
363
364
365 def Undo(self):
366 return self._projectDoc.RemoveFiles(self._files)
367
368
369 class ProjectRemoveFilesCommand(wx.lib.docview.Command):
370
371
372 def __init__(self, files):
373 wx.lib.docview.Command.__init__(self, canUndo = True)
374 self._files = files
375
376
377 def GetName(self):
378 if len(self._files) == 1:
379 return _("Remove File %s") % os.path.basename((self._files[0])[1])
380 else:
381 return _("Remove Files")
382
383
384 def Do(self):
385 status = False
386 projects = []
387 for data in self._files:
388 proj, filename = data
389 if proj not in projects:
390 projects.append(proj)
391 for project in projects:
392 files = []
393 for data in self._files:
394 proj, filename = data
395 if project == proj:
396 files.append(filename)
397 status = project.RemoveFiles(files) or status
398 return status
399
400
401 def Undo(self):
402 status = False
403 projects = []
404 for data in self._files:
405 proj, filename = data
406 if proj not in projects:
407 projects.append(proj)
408 for project in projects:
409 files = []
410 for data in self._files:
411 proj, filename = data
412 if project == proj:
413 files.append(filename)
414 status = project.AddFiles(files) or status
415 return status
416
417
418 class ProjectRenameFileCommand(wx.lib.docview.Command):
419
420
421 def __init__(self, projectDoc, oldFile, newFile, isProject = False):
422 wx.lib.docview.Command.__init__(self, canUndo = True)
423 self._projectDoc = projectDoc
424 self._oldFile = oldFile
425 self._newFile = newFile
426 self._isProject = isProject
427
428
429 def GetName(self):
430 return _("Rename File %s to %s") % (os.path.basename(self._oldFile), os.path.basename(self._newFile))
431
432
433 def Do(self):
434 return self._projectDoc.RenameFile(self._oldFile, self._newFile, self._isProject)
435
436
437 def Undo(self):
438 return self._projectDoc.RenameFile(self._newFile, self._oldFile, self._isProject)
439
440
441 class ProjectTreeCtrl(wx.TreeCtrl):
442
443
444 #----------------------------------------------------------------------------
445 # Overridden Methods
446 #----------------------------------------------------------------------------
447
448 def __init__(self, parent, id, style):
449 wx.TreeCtrl.__init__(self, parent, id, style = style)
450
451 templates = wx.GetApp().GetDocumentManager().GetTemplates()
452 iconList = wx.ImageList(16, 16, initialCount = len(templates))
453 self._iconIndexLookup = []
454 for template in templates:
455 icon = template.GetIcon()
456 if icon:
457 if icon.GetHeight() != 16 or icon.GetWidth() != 16:
458 icon.SetHeight(16)
459 icon.SetWidth(16)
460 if wx.GetApp().GetDebug():
461 print "Warning: icon for '%s' isn't 16x16, not crossplatform" % template._docTypeName
462 iconIndex = iconList.AddIcon(icon)
463 self._iconIndexLookup.append((template, iconIndex))
464
465 icon = getBlankIcon()
466 if icon.GetHeight() != 16 or icon.GetWidth() != 16:
467 icon.SetHeight(16)
468 icon.SetWidth(16)
469 if wx.GetApp().GetDebug():
470 print "Warning: getBlankIcon isn't 16x16, not crossplatform"
471 self._blankIconIndex = iconList.AddIcon(icon)
472 self.AssignImageList(iconList)
473
474
475 def OnCompareItems(self, item1, item2):
476 return cmp(self.GetItemText(item1).lower(), self.GetItemText(item2).lower())
477
478
479 def AppendItem(self, parent, filepath):
480 item = wx.TreeCtrl.AppendItem(self, parent, filepath)
481
482 found = False
483 template = wx.GetApp().GetDocumentManager().FindTemplateForPath(filepath)
484 if not template and parent == self.GetRootItem(): # If the parent is a root it's a new project
485 template = wx.GetApp().GetDocumentManager().FindTemplateForPath('.agp')
486 if template:
487 for t, iconIndex in self._iconIndexLookup:
488 if t is template:
489 self.SetItemImage(item, iconIndex, wx.TreeItemIcon_Normal)
490 self.SetItemImage(item, iconIndex, wx.TreeItemIcon_Expanded)
491 self.SetItemImage(item, iconIndex, wx.TreeItemIcon_Selected)
492 found = True
493 break
494
495 if not found:
496 self.SetItemImage(item, self._blankIconIndex, wx.TreeItemIcon_Normal)
497 self.SetItemImage(item, self._blankIconIndex, wx.TreeItemIcon_Expanded)
498 self.SetItemImage(item, self._blankIconIndex, wx.TreeItemIcon_Selected)
499
500 return item
501
502
503 #----------------------------------------------------------------------------
504 # Client Data
505 #----------------------------------------------------------------------------
506
507 def SetData(self, item, longFilename, projectDoc=None):
508 self.SetPyData(item, (longFilename, projectDoc))
509
510
511 def GetData(self, item):
512 """ returns longFilename and optional
513 """
514 data = self.GetPyData(item)
515 if not data:
516 return (None, None)
517 return data
518
519
520 def GetLongFilename(self, item):
521 return self.GetData(item)[0]
522
523
524 def GetProjectDoc(self, item):
525 return self.GetData(item)[1]
526
527
528 class ProjectView(wx.lib.docview.View):
529
530
531 #----------------------------------------------------------------------------
532 # Overridden methods
533 #----------------------------------------------------------------------------
534
535 def __init__(self, service = None):
536 wx.lib.docview.View.__init__(self)
537 self._service = service # not used, but kept to match other Services
538 self._treeCtrl = None
539 self._editingSoDontKillFocus = False
540 self._checkEditMenu = True
541
542
543 def Destroy(self):
544 projectService = wx.GetApp().GetService(ProjectService)
545 if projectService:
546 projectService.SetView(None)
547 wx.lib.docview.View.Destroy(self)
548
549
550 def GetDocument(self):
551 if not self._treeCtrl:
552 return None
553
554 items = self._treeCtrl.GetSelections()
555 if not items: # No selection, so just return first project
556 item = self._treeCtrl.GetFirstVisibleItem()
557 if item.IsOk():
558 return self._GetItemProject(item)
559 else:
560 return None
561
562 for item in items:
563 project = self._GetItemProject(item)
564 if project:
565 return project
566
567 return None
568
569
570 def GetDocumentManager(self): # Overshadow this since the superclass uses the view._viewDocument attribute directly, which the project editor doesn't use since it hosts multiple docs
571 return wx.GetApp().GetDocumentManager()
572
573
574 def OnChangeFilename(self):
575 if self.GetFrame():
576 title = _("Projects")
577 if self.GetDocumentManager().GetFlags() & wx.lib.docview.DOC_SDI and wx.GetApp().GetAppName():
578 title = title + " - " + wx.GetApp().GetAppName()
579 self.GetFrame().SetTitle(title)
580 project = self.GetDocument()
581 if project:
582 projectItem = self._GetProjectItem(project)
583 name = self._treeCtrl.GetItemText(self._GetProjectItem(project))
584 name2 = self._MakeProjectName(project)
585 if name != name2:
586 self._treeCtrl.SetItemText(projectItem, name2)
587 self._treeCtrl.SortChildren(self._treeCtrl.GetRootItem())
588
589
590 def Activate(self, activate = True):
591 if not wx.GetApp().IsMDI():
592 if activate and not self.IsShown():
593 self.Show()
594
595 if self.IsShown():
596 wx.lib.docview.View.Activate(self, activate = activate)
597 if activate and self._treeCtrl:
598 self._treeCtrl.SetFocus()
599
600
601 def OnCreate(self, doc, flags):
602 config = wx.ConfigBase_Get()
603 if wx.GetApp().IsMDI():
604 self._embeddedWindow = wx.GetApp().GetTopWindow().GetEmbeddedWindow(wx.lib.pydocview.EMBEDDED_WINDOW_TOPLEFT)
605 self.SetFrame(self._embeddedWindow)
606 frame = self._embeddedWindow
607 else:
608 self._embeddedWindow = None
609 pos = config.ReadInt("ProjectFrameXLoc", -1), config.ReadInt("ProjectFrameYLoc", -1)
610 # make sure frame is visible
611 screenWidth = wx.SystemSettings.GetMetric(wx.SYS_SCREEN_X)
612 screenHeight = wx.SystemSettings.GetMetric(wx.SYS_SCREEN_Y)
613 if pos[0] < 0 or pos[0] >= screenWidth or pos[1] < 0 or pos[1] >= screenHeight:
614 pos = wx.DefaultPosition
615
616 size = wx.Size(config.ReadInt("ProjectFrameXSize", -1), config.ReadInt("ProjectFrameYSize", -1))
617
618 title = _("Projects")
619 if self.GetDocumentManager().GetFlags() & wx.lib.docview.DOC_SDI and wx.GetApp().GetAppName():
620 title = title + " - " + wx.GetApp().GetAppName()
621
622 frame = wx.GetApp().CreateDocumentFrame(self, doc, 0, title = title, pos = pos, size = size)
623 if config.ReadInt("ProjectFrameMaximized", False):
624 frame.Maximize(True)
625
626 sizer = wx.BoxSizer()
627 self._treeCtrl = ProjectTreeCtrl(frame, -1, style = wx.TR_HIDE_ROOT | wx.TR_HAS_BUTTONS | wx.TR_EDIT_LABELS | wx.TR_DEFAULT_STYLE | wx.TR_MULTIPLE)
628 self._treeCtrl.AddRoot(_("Projects"))
629 wx.EVT_TREE_BEGIN_DRAG(self._treeCtrl, self._treeCtrl.GetId(), self.OnBeginDrag)
630 wx.EVT_TREE_END_DRAG(self._treeCtrl, self._treeCtrl.GetId(), self.OnEndDrag)
631
632 if self._embeddedWindow:
633 sizer.Add(self._treeCtrl)
634 sizer.Fit(frame)
635 else:
636 sizer.Add(self._treeCtrl, 1, wx.EXPAND, 0)
637 frame.SetSizer(sizer)
638 frame.Layout()
639 self.Activate()
640
641 if wx.GetApp().IsMDI():
642 wx.EVT_SET_FOCUS(self._treeCtrl, self.OnFocus)
643 wx.EVT_KILL_FOCUS(self._treeCtrl, self.OnKillFocus)
644
645 if self.GetDocumentManager().GetFlags() & wx.lib.docview.DOC_SDI:
646 wx.EVT_TREE_ITEM_ACTIVATED(self._treeCtrl, self._treeCtrl.GetId(), self.OnOpenSelectionSDI)
647 else:
648 wx.EVT_TREE_ITEM_ACTIVATED(self._treeCtrl, self._treeCtrl.GetId(), self.OnOpenSelection)
649 wx.EVT_TREE_BEGIN_LABEL_EDIT(self._treeCtrl, self._treeCtrl.GetId(), self.OnBeginLabelEdit)
650 wx.EVT_TREE_END_LABEL_EDIT(self._treeCtrl, self._treeCtrl.GetId(), self.OnEndLabelEdit)
651 wx.EVT_RIGHT_DOWN(self._treeCtrl, self.OnRightClick)
652 wx.EVT_KEY_DOWN(self._treeCtrl, self.OnKeyPressed)
653 # wx.EVT_COMMAND_RIGHT_CLICK(self._treeCtrl, self._treeCtrl.GetId(), self.OnRightClick) # wxBug: This isn't working for some reason
654
655 # drag-and-drop support
656 dt = ProjectFileDropTarget(self)
657 self._treeCtrl.SetDropTarget(dt)
658
659 return True
660
661
662 def OnBeginDrag(self, event):
663 item = event.GetItem()
664 if item.IsOk():
665 if item == self._treeCtrl.GetRootItem():
666 return
667 self._draggingItem = item
668 event.Allow()
669
670
671 def OnEndDrag(self, event):
672 item = event.GetItem()
673 if item.IsOk():
674 # don't allow object to be dragged to itself
675 if item == self._draggingItem:
676 return
677
678 rootItem = self._treeCtrl.GetRootItem()
679
680 # don't let object replace root view
681 if item == rootItem:
682 wx.MessageBox(_("Cannot replace root view with item."))
683 return
684
685 # don't allow object to be dragged to a direct descendant
686 ancestor = self._treeCtrl.GetItemParent(item)
687 while ancestor != rootItem:
688 if ancestor == self._draggingItem:
689 wx.MessageBox(_("Cannot make item direct descendant of self."))
690 return
691 else:
692 ancestor = self._treeCtrl.GetItemParent(ancestor)
693
694 if self._treeCtrl.GetItemParent(item) == self._treeCtrl.GetItemParent(self._draggingItem):
695 # put it in same folder as it was originally, no-op.
696 return
697 if item == self._treeCtrl.GetItemParent(self._draggingItem):
698 # put it in same folder as it was originally, no-op.
699 return
700
701 self.GetDocument().GetCommandProcessor().Submit(ProjectEditorMoveCommand(self, item, self._draggingItem))
702
703
704 def WriteProjectConfig(self):
705 frame = self.GetFrame()
706 config = wx.ConfigBase_Get()
707 if frame and not self._embeddedWindow:
708 if not frame.IsMaximized():
709 config.WriteInt("ProjectFrameXLoc", frame.GetPositionTuple()[0])
710 config.WriteInt("ProjectFrameYLoc", frame.GetPositionTuple()[1])
711 config.WriteInt("ProjectFrameXSize", frame.GetSizeTuple()[0])
712 config.WriteInt("ProjectFrameYSize", frame.GetSizeTuple()[1])
713 config.WriteInt("ProjectFrameMaximized", frame.IsMaximized())
714
715 if config.ReadInt("ProjectSaveDocs", True):
716 projectFileNames = []
717 projectExpanded = []
718 if self._treeCtrl:
719 for projectItem in self._GetChildItems(self._treeCtrl.GetRootItem()):
720 project = self._GetItemProject(projectItem)
721 if not project.OnSaveModified():
722 return
723 if project.GetDocumentSaved(): # Might be a new document and "No" selected to save it
724 projectFileNames.append(str(project.GetFilename()))
725 projectExpanded.append(self._treeCtrl.IsExpanded(projectItem))
726 config.Write("ProjectSavedDocs", projectFileNames.__repr__())
727 config.Write("ProjectExpandedSavedDocs", projectExpanded.__repr__())
728
729
730 def OnClose(self, deleteWindow = True):
731 if self.GetDocumentManager().GetFlags() & wx.lib.docview.DOC_SDI:
732 self.WriteProjectConfig()
733 project = self.GetDocument()
734 if not project:
735 return True
736 if not self.GetDocument().Close():
737 return True
738 self.Activate(False)
739 if project:
740 projectItem = self._GetProjectItem(project)
741 if projectItem:
742 self._treeCtrl.Delete(projectItem)
743 # We don't need to delete the window since it is a floater/embedded
744 return True
745
746
747 def _GetParentFrame(self):
748 return wx.GetTopLevelParent(self.GetFrame())
749
750
751 def OnUpdate(self, sender = None, hint = None):
752 wx.lib.docview.View.OnUpdate(self, sender, hint)
753 if hint:
754 if hint[0] == "add":
755 projectItem = self._GetProjectItem(hint[1])
756 files = hint[2]
757 self._treeCtrl.UnselectAll()
758 self._treeCtrl.Expand(projectItem)
759 item = None
760 for file in files:
761 item = self._treeCtrl.AppendItem(projectItem, os.path.basename(file))
762 self._treeCtrl.SetData(item, file)
763 self._treeCtrl.SelectItem(item)
764 self._treeCtrl.EnsureVisible(item)
765 self._treeCtrl.SortChildren(projectItem)
766 if item:
767 self._treeCtrl.EnsureVisible(item) # need to be called after SortChildren
768 elif hint[0] == "remove":
769 projectItem = self._GetProjectItem(hint[1])
770 files = hint[2]
771 self._treeCtrl.UnselectAll()
772 children = self._GetChildItems(projectItem)
773 for child in children:
774 if self._GetItemFile(child) in files:
775 self._treeCtrl.Delete(child)
776 elif hint[0] == "select":
777 projectItem = self._GetProjectItem(hint[1])
778 files = hint[2]
779 self._treeCtrl.UnselectAll()
780 children = self._GetChildItems(projectItem)
781 for child in children:
782 if self._GetItemFile(child) in files:
783 self._treeCtrl.SelectItem(child)
784 self._treeCtrl.EnsureVisible(child)
785 elif hint[0] == "rename":
786 projectItem = self._GetProjectItem(hint[1])
787 self._treeCtrl.SetItemText(projectItem, os.path.basename(hint[2]))
788
789
790 def ProcessEvent(self, event):
791 id = event.GetId()
792 if id == ProjectService.ADD_FILES_TO_PROJECT_ID:
793 self.OnAddFileToProject(event)
794 return True
795 elif id == ProjectService.ADD_ALL_FILES_TO_PROJECT_ID:
796 self.OnAddDirToProject(event)
797 return True
798 elif id == ProjectService.ADD_CURRENT_FILE_TO_PROJECT_ID:
799 return False # Implement this one in the service
800 elif id == ProjectService.RENAME_ID:
801 self.OnRename(event)
802 return True
803 elif id == ProjectService.DELETE_FILE_ID:
804 self.OnDeleteFile(event)
805 return True
806 elif id == wx.ID_CUT:
807 self.OnCut(event)
808 return True
809 elif id == wx.ID_COPY:
810 self.OnCopy(event)
811 return True
812 elif id == wx.ID_PASTE:
813 self.OnPaste(event)
814 return True
815 elif (id == wx.ID_CLEAR
816 or id == ProjectService.REMOVE_FROM_PROJECT):
817 self.OnClear(event)
818 return True
819 elif id == wx.ID_SELECTALL:
820 self.OnSelectAll(event)
821 return True
822 elif id == ProjectService.OPEN_SELECTION_ID:
823 self.OnOpenSelection(event)
824 return True
825 elif id == wx.lib.pydocview.FilePropertiesService.PROPERTIES_ID:
826 self.OnProperties(event)
827 return True
828 else:
829 return False
830
831
832 def ProcessUpdateUIEvent(self, event):
833 # Hack: The edit menu is not being set for projects that are preloaded at startup, so make sure it is OK here
834 if self._checkEditMenu:
835 doc = self.GetDocument()
836 if doc and not doc.GetCommandProcessor().GetEditMenu():
837 doc.GetCommandProcessor().SetEditMenu(wx.GetApp().GetEditMenu(self._GetParentFrame()))
838 self._checkEditMenu = False
839
840 id = event.GetId()
841 if (id == wx.ID_CUT
842 or id == wx.ID_COPY
843 or id == ProjectService.RENAME_ID
844 or id == ProjectService.ADD_FILES_TO_PROJECT_ID
845 or id == ProjectService.ADD_ALL_FILES_TO_PROJECT_ID
846 or id == wx.lib.pydocview.FilePropertiesService.PROPERTIES_ID):
847 event.Enable(self._HasSelection())
848 return True
849 elif id == ProjectService.DELETE_FILE_ID:
850 event.Enable(len(self.GetSelectedFiles()) > 0)
851 return True
852 elif id == ProjectService.ADD_CURRENT_FILE_TO_PROJECT_ID:
853 event.Enable(False)
854 return True
855 elif id == wx.ID_PASTE:
856 event.Enable(self.CanPaste())
857 return True
858 elif id == wx.ID_SELECTALL:
859 event.Enable(self._HasFiles())
860 return True
861 elif (id == wx.ID_CLEAR
862 or id == ProjectService.REMOVE_FROM_PROJECT
863 or id == ProjectService.OPEN_SELECTION_ID):
864 event.Enable(self._HasFilesSelected())
865 return True
866 elif (id == wx.ID_PREVIEW
867 or id == wx.ID_PRINT):
868 event.Enable(False)
869 return True
870 else:
871 return False
872
873 #----------------------------------------------------------------------------
874 # Display Methods
875 #----------------------------------------------------------------------------
876
877 def IsShown(self):
878 if not self.GetFrame():
879 return False
880 return self.GetFrame().IsShown()
881
882
883 def Hide(self):
884 self.Show(False)
885
886
887 def Show(self, show = True):
888 self.GetFrame().Show(show)
889 if wx.GetApp().IsMDI():
890 mdiParentFrame = wx.GetApp().GetTopWindow()
891 mdiParentFrame.ShowEmbeddedWindow(self.GetFrame(), show)
892
893
894 #----------------------------------------------------------------------------
895 # Methods for ProjectDocument and ProjectService to call
896 #----------------------------------------------------------------------------
897
898 def SetExpandedProjects(self, expandedProjects):
899 self._treeCtrl.UnselectAll()
900 firstItem = None
901 for i, item in enumerate(self._GetChildItems(self._treeCtrl.GetRootItem())):
902 if i == 0:
903 firstItem = item
904
905 if expandedProjects[i]:
906 self._treeCtrl.Expand(item)
907 else:
908 self._treeCtrl.Collapse(item)
909
910 if firstItem:
911 self._treeCtrl.EnsureVisible(firstItem)
912
913
914 def GetSelectedFile(self):
915 for item in self._treeCtrl.GetSelections():
916 return self._GetItemFile(item)
917
918
919 def GetSelectedFiles(self):
920 filenames = []
921 for item in self._treeCtrl.GetSelections():
922 filename = self._GetItemFile(item)
923 if filename and filename not in filenames:
924 filenames.append(filename)
925 return filenames
926
927
928 def GetSelectedProjects(self):
929 filenames = []
930 for item in self._treeCtrl.GetSelections():
931 if self._IsItemProject(item):
932 filename = self._treeCtrl.GetLongFilename(item)
933 if filename and filename not in filenames:
934 filenames.append(filename)
935 return filenames
936
937
938 def AddProjectToView(self, document):
939 rootItem = self._treeCtrl.GetRootItem()
940 projectItem = self._treeCtrl.AppendItem(rootItem, self._MakeProjectName(document))
941 self._treeCtrl.SetData(projectItem, document.GetFilename(), document)
942 for file in document.GetFiles():
943 fileItem = self._treeCtrl.AppendItem(projectItem, os.path.basename(file))
944 self._treeCtrl.SetData(fileItem, file)
945 self._treeCtrl.SortChildren(rootItem)
946 self._treeCtrl.SortChildren(projectItem)
947 self._treeCtrl.UnselectAll()
948 self._treeCtrl.Expand(projectItem)
949 self._treeCtrl.SelectItem(projectItem)
950 if self._embeddedWindow:
951 document.GetCommandProcessor().SetEditMenu(wx.GetApp().GetEditMenu(self._GetParentFrame()))
952
953
954 def HasFocus(self):
955 winWithFocus = wx.Window.FindFocus()
956 if not winWithFocus:
957 return False
958 while winWithFocus:
959 if winWithFocus == self._treeCtrl:
960 return True
961 winWithFocus = winWithFocus.GetParent()
962 return False
963
964
965 #----------------------------------------------------------------------------
966 # Control events
967 #----------------------------------------------------------------------------
968
969 def OnProperties(self, event):
970 items = self._treeCtrl.GetSelections()
971 if not items:
972 return
973 item = items[0]
974 if self._IsItemProject(item):
975 projectPropertiesDialog = ProjectPropertiesDialog(wx.GetApp().GetTopWindow(), self._GetItemProject(item).GetFilename())
976 if projectPropertiesDialog.ShowModal() == wx.ID_OK:
977 pass # Handle OK
978 projectPropertiesDialog.Destroy()
979 elif self._IsItemFile(item):
980 filePropertiesService = wx.GetApp().GetService(wx.lib.pydocview.FilePropertiesService)
981 filePropertiesService.ShowPropertiesDialog(self._GetItemFile(item))
982
983
984 def OnAddFileToProject(self, event):
985 if wx.Platform == "__WXMSW__" or wx.Platform == "__WXGTK__" or wx.Platform == "__WXMAC__":
986 allfilter = ''
987 descr = ''
988 for temp in self.GetDocumentManager()._templates:
989 if temp.IsVisible():
990 if len(descr) > 0:
991 descr = descr + _('|')
992 allfilter = allfilter + _(';')
993 descr = descr + temp.GetDescription() + _(" (") + temp.GetFileFilter() + _(") |") + temp.GetFileFilter() # spacing is important, make sure there is no space after the "|", it causes a bug on wx_gtk
994 allfilter = allfilter + temp.GetFileFilter()
995 descr = _("All (%s)|%s|%s|Any (*.*) | *.*") % (allfilter, allfilter, descr) # spacing is important, make sure there is no space after the "|", it causes a bug on wx_gtk
996 else:
997 descr = _("*.*")
998
999 startDirectory = os.path.dirname(self.GetDocument().GetFilename())
1000
1001 if True or _WINDOWS:
1002 dialog = wx.FileDialog(self.GetFrame(), _("Add Files"), startDirectory, "", descr, wx.OPEN | wx.HIDE_READONLY | wx.MULTIPLE)
1003 if dialog.ShowModal() != wx.ID_OK:
1004 return
1005 paths = dialog.GetPaths()
1006 dialog.Destroy()
1007 else:
1008 paths = wx.FileSelector(_("Add Files"), startDirectory, "", wildcard = descr, flags = wx.OPEN | wx.HIDE_READONLY | wx.MULTIPLE, parent=self.GetFrame())
1009 if type(paths) == types.StringType:
1010 paths = [paths]
1011 if len(paths):
1012 self.GetDocument().GetCommandProcessor().Submit(ProjectAddFilesCommand(self.GetDocument(), paths))
1013 self.Activate(True) # after add, should put focus on project editor
1014
1015
1016 def OnAddDirToProject(self, event):
1017 frame = wx.Dialog(None, -1, _("Add Directory Files to Project"), size= (320,200))
1018 contentSizer = wx.BoxSizer(wx.VERTICAL)
1019
1020 flexGridSizer = wx.FlexGridSizer(cols = 2, vgap=HALF_SPACE, hgap=HALF_SPACE)
1021 flexGridSizer.Add(wx.StaticText(frame, -1, _("Directory:")), 0, wx.ALIGN_CENTER_VERTICAL, 0)
1022 lineSizer = wx.BoxSizer(wx.HORIZONTAL)
1023 dirCtrl = wx.TextCtrl(frame, -1, os.path.dirname(self.GetDocument().GetFilename()), size=(250,-1))
1024 dirCtrl.SetToolTipString(dirCtrl.GetValue())
1025 lineSizer.Add(dirCtrl, 1, wx.ALIGN_CENTER_VERTICAL|wx.EXPAND)
1026 findDirButton = wx.Button(frame, -1, _("Browse..."))
1027 lineSizer.Add(findDirButton, 0, wx.LEFT|wx.ALIGN_CENTER_VERTICAL, HALF_SPACE)
1028 flexGridSizer.Add(lineSizer, 1, wx.EXPAND)
1029
1030 def OnBrowseButton(event):
1031 dlg = wx.DirDialog(frame, _("Choose a directory:"), style=wx.DD_DEFAULT_STYLE)
1032 dir = dirCtrl.GetValue()
1033 if len(dir):
1034 dlg.SetPath(dir)
1035 if dlg.ShowModal() == wx.ID_OK:
1036 dirCtrl.SetValue(dlg.GetPath())
1037 dirCtrl.SetToolTipString(dirCtrl.GetValue())
1038 dirCtrl.SetInsertionPointEnd()
1039
1040 dlg.Destroy()
1041 wx.EVT_BUTTON(findDirButton, -1, OnBrowseButton)
1042
1043 visibleTemplates = []
1044 for template in self.GetDocumentManager()._templates:
1045 if template.IsVisible():
1046 visibleTemplates.append(template)
1047
1048 choices = []
1049 allfilter = ''
1050 descr = ''
1051 for template in visibleTemplates:
1052 if len(descr) > 0:
1053 descr = descr + _('|')
1054 allfilter = allfilter + _(';')
1055 descr = template.GetDescription() + _(" (") + template.GetFileFilter() + _(")")
1056 choices.append(descr)
1057 allfilter = allfilter + template.GetFileFilter()
1058 choices.insert(0, _("All (%s)") % allfilter) # first item
1059 choices.append(_("Any (*.*)")) # last item
1060 filterChoice = wx.Choice(frame, -1, size=(250, -1), choices=choices)
1061 filterChoice.SetSelection(0)
1062 filterChoice.SetToolTipString(_("Select file type filter."))
1063 flexGridSizer.Add(wx.StaticText(frame, -1, _("Files of type:")), 0, wx.ALIGN_CENTER_VERTICAL)
1064 flexGridSizer.Add(filterChoice, 1, wx.EXPAND)
1065
1066 contentSizer.Add(flexGridSizer, 0, wx.ALL|wx.EXPAND, SPACE)
1067
1068 subfolderCtrl = wx.CheckBox(frame, -1, _("Add files from subdirectories"))
1069 subfolderCtrl.SetValue(True)
1070 contentSizer.Add(subfolderCtrl, 0, wx.LEFT|wx.ALIGN_CENTER_VERTICAL, SPACE)
1071
1072 buttonSizer = wx.BoxSizer(wx.HORIZONTAL)
1073 findBtn = wx.Button(frame, wx.ID_OK, _("Add"))
1074 findBtn.SetDefault()
1075 buttonSizer.Add(findBtn, 0, wx.RIGHT, HALF_SPACE)
1076 buttonSizer.Add(wx.Button(frame, wx.ID_CANCEL), 0)
1077 contentSizer.Add(buttonSizer, 0, wx.ALL|wx.ALIGN_RIGHT, SPACE)
1078
1079 frame.SetSizer(contentSizer)
1080 frame.Fit()
1081
1082 status = frame.ShowModal()
1083
1084 passedCheck = False
1085 while status == wx.ID_OK and not passedCheck:
1086 if not os.path.exists(dirCtrl.GetValue()):
1087 dlg = wx.MessageDialog(frame,
1088 _("'%s' does not exist.") % dirCtrl.GetValue(),
1089 _("Find in Directory"),
1090 wx.OK | wx.ICON_EXCLAMATION
1091 )
1092 dlg.ShowModal()
1093 dlg.Destroy()
1094
1095 status = frame.ShowModal()
1096 else:
1097 passedCheck = True
1098
1099 if status == wx.ID_OK:
1100 frame.Destroy()
1101
1102 wx.GetApp().GetTopWindow().SetCursor(wx.StockCursor(wx.CURSOR_WAIT))
1103
1104 doc = self.GetDocument()
1105 searchSubfolders = subfolderCtrl.IsChecked()
1106 dirString = dirCtrl.GetValue()
1107
1108 if os.path.isfile(dirString):
1109 # If they pick a file explicitly, we won't prevent them from adding it even if it doesn't match the filter.
1110 # We'll assume they know what they're doing.
1111 paths = [dirString]
1112 else:
1113 paths = []
1114
1115 index = filterChoice.GetSelection()
1116 lastIndex = filterChoice.GetCount()-1
1117 if index and index != lastIndex: # if not All or Any
1118 template = visibleTemplates[index-1]
1119
1120 # do search in files on disk
1121 for root, dirs, files in os.walk(dirString):
1122 if not searchSubfolders and root != dirString:
1123 break
1124
1125 for name in files:
1126 if index == 0: # All
1127 for template in visibleTemplates:
1128 if template.FileMatchesTemplate(name):
1129 filename = os.path.join(root, name)
1130
1131 # if already in project, don't add it, otherwise undo will remove it from project even though it was already in it.
1132 if doc.IsFileInProject(filename):
1133 break
1134
1135 paths.append(filename)
1136 break
1137 elif index == lastIndex: # Any
1138 filename = os.path.join(root, name)
1139 # if already in project, don't add it, otherwise undo will remove it from project even though it was already in it.
1140 if not doc.IsFileInProject(filename):
1141 paths.append(filename)
1142 else: # use selected filter
1143 if template.FileMatchesTemplate(name):
1144 filename = os.path.join(root, name)
1145 # if already in project, don't add it, otherwise undo will remove it from project even though it was already in it.
1146 if not doc.IsFileInProject(filename):
1147 paths.append(filename)
1148
1149 wx.GetApp().GetTopWindow().SetCursor(wx.StockCursor(wx.CURSOR_DEFAULT))
1150
1151 doc.GetCommandProcessor().Submit(ProjectAddFilesCommand(doc, paths))
1152 self.Activate(True) # after add, should put focus on project editor
1153 else:
1154 frame.Destroy()
1155
1156
1157 def DoAddFilesToProject(self, filenames):
1158 # method used by Drag-n-Drop to add files to current Project
1159 self.GetDocument().GetCommandProcessor().Submit(ProjectAddFilesCommand(self.GetDocument(), filenames))
1160
1161
1162 def DoSelectFiles(self, filenames):
1163 # method used by Drag-n-Drop to select files in current Project
1164 self._treeCtrl.UnselectAll()
1165 for file in filenames:
1166 item = self._GetFileItem(longFileName=file)
1167 if item:
1168 self._treeCtrl.SelectItem(item, True)
1169 self._treeCtrl.EnsureVisible(item)
1170
1171
1172 def DoSelectProject(self, x, y):
1173 # method used by Drag-n-Drop to set current Project based on cursor position
1174 item, flag = self._treeCtrl.HitTest((x,y))
1175 if not item:
1176 return False
1177
1178 project = self._GetItemProject(item)
1179 if not project:
1180 return False
1181
1182 projectItem = self._GetProjectItem(project)
1183 self._treeCtrl.UnselectAll()
1184 self._treeCtrl.SelectItem(projectItem)
1185 return True
1186
1187
1188 def OnFocus(self, event):
1189 wx.GetApp().GetDocumentManager().ActivateView(self)
1190 event.Skip()
1191
1192
1193 def OnKillFocus(self, event):
1194 # Get the top MDI window and "activate" it since it is already active from the perspective of the MDIParentFrame
1195 # wxBug: Would be preferable to call OnActivate, but have casting problem, so added Activate method to docview.DocMDIChildFrame
1196 if not self._editingSoDontKillFocus: # wxBug: This didn't used to happen, but now when you start to edit an item in a wxTreeCtrl it puts out a KILL_FOCUS event, so we need to detect it
1197 childFrame = wx.GetApp().GetTopWindow().GetActiveChild()
1198 if childFrame:
1199 childFrame.Activate()
1200 event.Skip()
1201
1202
1203 def OnRightClick(self, event):
1204 self.Activate(True)
1205 if not self._treeCtrl.GetSelections():
1206 return
1207 if len(self._treeCtrl.GetSelections()) == 1 and self._IsItemRoot(self._treeCtrl.GetSelections()[0]):
1208 return # Don't do a menu if it's just the root item selected
1209 menu = wx.Menu()
1210 if self._HasFilesSelected(): # Files context
1211 menu.Append(ProjectService.OPEN_SELECTION_ID, _("&Open"), _("Opens the selection"))
1212 menu.Enable(ProjectService.OPEN_SELECTION_ID, True)
1213 wx.EVT_MENU(self._GetParentFrame(), ProjectService.OPEN_SELECTION_ID, self.OnOpenSelection)
1214 itemIDs = [None]
1215 for item in self._treeCtrl.GetSelections():
1216 if self._IsItemProcessModelFile(item):
1217 itemIDs = [None, ProjectService.RUN_SELECTED_PM_ID, None]
1218 break
1219 else: # Project context
1220 itemIDs = [wx.ID_CLOSE, wx.ID_SAVE, wx.ID_SAVEAS, None]
1221 menuBar = self._GetParentFrame().GetMenuBar()
1222 itemIDs = itemIDs + [ProjectService.ADD_FILES_TO_PROJECT_ID, ProjectService.ADD_ALL_FILES_TO_PROJECT_ID, ProjectService.REMOVE_FROM_PROJECT]
1223 svnIDs = [SVNService.SVNService.SVN_UPDATE_ID, SVNService.SVNService.SVN_CHECKIN_ID, SVNService.SVNService.SVN_REVERT_ID]
1224 if SVN_INSTALLED:
1225 itemIDs = itemIDs + [None, SVNService.SVNService.SVN_UPDATE_ID, SVNService.SVNService.SVN_CHECKIN_ID, SVNService.SVNService.SVN_REVERT_ID]
1226 globalIDs = [wx.ID_UNDO, wx.ID_REDO, wx.ID_CLOSE, wx.ID_SAVE, wx.ID_SAVEAS]
1227 itemIDs = itemIDs + [None, wx.ID_UNDO, wx.ID_REDO, None, wx.ID_CUT, wx.ID_COPY, wx.ID_PASTE, wx.ID_CLEAR, None, wx.ID_SELECTALL, ProjectService.RENAME_ID, ProjectService.DELETE_FILE_ID, None, wx.lib.pydocview.FilePropertiesService.PROPERTIES_ID]
1228 for itemID in itemIDs:
1229 if not itemID:
1230 menu.AppendSeparator()
1231 else:
1232 if itemID == ProjectService.RUN_SELECTED_PM_ID:
1233 menu.Append(ProjectService.RUN_SELECTED_PM_ID, _("Run Process"))
1234 wx.EVT_MENU(self._GetParentFrame(), ProjectService.RUN_SELECTED_PM_ID, self.OnRunSelectedPM)
1235 elif itemID == ProjectService.REMOVE_FROM_PROJECT:
1236 menu.Append(ProjectService.REMOVE_FROM_PROJECT, _("Remove Selected Files from Project"))
1237 wx.EVT_MENU(self._GetParentFrame(), ProjectService.REMOVE_FROM_PROJECT, self.OnClear)
1238 wx.EVT_UPDATE_UI(self._GetParentFrame(), ProjectService.REMOVE_FROM_PROJECT, self._GetParentFrame().ProcessUpdateUIEvent)
1239 else:
1240 svnService = wx.GetApp().GetService(SVNService.SVNService)
1241 item = menuBar.FindItemById(itemID)
1242 if item:
1243 if itemID in svnIDs:
1244 if SVN_INSTALLED and svnService:
1245 wx.EVT_MENU(self._GetParentFrame(), itemID, svnService.ProcessEvent)
1246 elif itemID in globalIDs:
1247 pass
1248 else:
1249 wx.EVT_MENU(self._treeCtrl, itemID, self.ProcessEvent)
1250 menu.Append(itemID, item.GetLabel())
1251 self._treeCtrl.PopupMenu(menu, wx.Point(event.GetX(), event.GetY()))
1252 menu.Destroy()
1253
1254
1255 def OnRunSelectedPM(self, event):
1256 projectService = wx.GetApp().GetService(ProjectService)
1257 if projectService:
1258 projectService.OnRunProcessModel(event, runSelected=True)
1259
1260
1261 def OnRename(self, event):
1262 if self._treeCtrl.GetSelections():
1263 self._treeCtrl.EditLabel(self._treeCtrl.GetSelections()[0])
1264
1265
1266 def OnBeginLabelEdit(self, event):
1267 self._editingSoDontKillFocus = True
1268 item = event.GetItem()
1269 if not self._IsItemFile(item) and not self._IsItemProject(item):
1270 event.Veto()
1271
1272
1273 def OnEndLabelEdit(self, event):
1274 self._editingSoDontKillFocus = False
1275 item = event.GetItem()
1276 newName = event.GetLabel()
1277 if not newName or (not self._IsItemFile(item) and not self._IsItemProject(item)):
1278 event.Veto()
1279 return
1280 if self._IsItemFile(item):
1281 oldFile = self._GetItemFile(item)
1282 newFile = os.path.join(os.path.split(oldFile)[0], newName)
1283 project = self._GetItemProject(item)
1284 if not project.GetCommandProcessor().Submit(ProjectRenameFileCommand(project, oldFile, newFile)):
1285 event.Veto()
1286 return
1287 self._treeCtrl.SortChildren(self._treeCtrl.GetItemParent(self._treeCtrl.GetSelections()[0]))
1288 elif self._IsItemProject(item):
1289 oldFile = self._GetItemProject(item).GetFilename()
1290 newFile = os.path.join(os.path.split(oldFile)[0], newName)
1291 project = self._GetItemProject(item)
1292 if not project.GetCommandProcessor().Submit(ProjectRenameFileCommand(project, oldFile, newFile, True)):
1293 event.Veto()
1294 return
1295 self._treeCtrl.SortChildren(self._treeCtrl.GetRootItem())
1296
1297
1298 def CanPaste(self):
1299 # wxBug: Should be able to use IsSupported/IsSupportedFormat here
1300 #fileDataObject = wx.FileDataObject()
1301 #hasFilesInClipboard = wx.TheClipboard.IsSupportedFormat(wx.FileDataObject)
1302 if not wx.TheClipboard.IsOpened():
1303 if wx.TheClipboard.Open():
1304 fileDataObject = wx.FileDataObject()
1305 hasFilesInClipboard = wx.TheClipboard.GetData(fileDataObject)
1306 wx.TheClipboard.Close()
1307 else:
1308 hasFilesInClipboard = False
1309 return hasFilesInClipboard
1310
1311
1312 def OnCut(self, event):
1313 self.OnCopy(event)
1314 self.OnClear(event)
1315
1316
1317 def OnCopy(self, event):
1318 fileDataObject = wx.FileDataObject()
1319 items = self._treeCtrl.GetSelections()
1320 for item in items:
1321 if self._IsItemFile(item):
1322 file = self._treeCtrl.GetLongFilename(item)
1323 fileDataObject.AddFile(file)
1324 if len(fileDataObject.GetFilenames()) > 0 and wx.TheClipboard.Open():
1325 wx.TheClipboard.SetData(fileDataObject)
1326 wx.TheClipboard.Close()
1327
1328
1329 def OnPaste(self, event):
1330 if wx.TheClipboard.Open():
1331 fileDataObject = wx.FileDataObject()
1332 if wx.TheClipboard.GetData(fileDataObject):
1333 self.GetDocument().GetCommandProcessor().Submit(ProjectAddFilesCommand(self.GetDocument(), fileDataObject.GetFilenames()))
1334 wx.TheClipboard.Close()
1335
1336
1337 def OnClear(self, event):
1338 items = self._treeCtrl.GetSelections()
1339 files = []
1340 for item in items:
1341 if self._IsItemFile(item):
1342 files.append((self._GetItemProject(item), self._GetItemFile(item)))
1343 self.GetDocument().GetCommandProcessor().Submit(ProjectRemoveFilesCommand(files))
1344
1345
1346 def OnDeleteFile(self, event):
1347 yesNoMsg = wx.MessageDialog(self.GetFrame(),
1348 _("Delete cannot be reversed.\n\nRemove the selected files from the\nprojects and file system permanently?"),
1349 _("Delete File"),
1350 wx.YES_NO|wx.ICON_QUESTION)
1351 if yesNoMsg.ShowModal() == wx.ID_NO:
1352 return
1353
1354 items = self._treeCtrl.GetSelections()
1355 files = []
1356 delFiles = []
1357 for item in items:
1358 if self._IsItemFile(item):
1359 filename = self._GetItemFile(item)
1360 files.append((self._GetItemProject(item), filename))
1361 if filename not in delFiles:
1362 delFiles.append(filename)
1363
1364 # remove selected files from projects
1365 projects = []
1366 for data in files:
1367 proj, filename = data
1368 if proj not in projects:
1369 projects.append(proj)
1370 for project in projects:
1371 filenames = []
1372 for data in files:
1373 proj, filename = data
1374 if project == proj:
1375 filenames.append(filename)
1376 project.RemoveFiles(filenames)
1377
1378 # remove selected files from file system
1379 for filename in delFiles:
1380 if os.path.exists(filename):
1381 try:
1382 os.remove(filename)
1383 except:
1384 wx.MessageBox("Could not delete '%s'. %s" % (os.path.basename(filename), sys.exc_value),
1385 _("Delete File"),
1386 wx.OK | wx.ICON_EXCLAMATION)
1387
1388
1389 def OnKeyPressed(self, event):
1390 key = event.KeyCode()
1391 if key == wx.WXK_DELETE:
1392 self.OnClear(event)
1393 else:
1394 event.Skip()
1395
1396
1397 def OnSelectAll(self, event):
1398 project = self.GetDocument()
1399 if project:
1400 self._treeCtrl.UnselectAll()
1401 for child in self._GetChildItems(self._GetProjectItem(project)):
1402 self._treeCtrl.SelectItem(child)
1403
1404
1405 def OnOpenSelectionSDI(self, event):
1406 # Do a call after so that the second mouseclick on a doubleclick doesn't reselect the project window
1407 wx.CallAfter(self.OnOpenSelection, None)
1408
1409
1410 def OnOpenSelection(self, event):
1411 doc = None
1412 try:
1413 items = self._treeCtrl.GetSelections()
1414 for item in items:
1415 if self._IsItemFile(item):
1416 filepath = self._GetItemFile(item)
1417 if not os.path.exists(filepath):
1418 msgTitle = wx.GetApp().GetAppName()
1419 if not msgTitle:
1420 msgTitle = _("File Not Found")
1421 yesNoMsg = wx.MessageDialog(self.GetFrame(),
1422 _("The file '%s' was not found in '%s'.\n\nWould you like to browse for the file?") % (wx.lib.docview.FileNameFromPath(filepath), wx.lib.docview.PathOnly(filepath)),
1423 msgTitle,
1424 wx.YES_NO|wx.ICON_QUESTION
1425 )
1426 if yesNoMsg.ShowModal() == wx.ID_NO:
1427 continue
1428 findFile = wx.FileDialog(self.GetFrame(),
1429 _("Choose a file"),
1430 wx.lib.docview.PathOnly(filepath),
1431 wx.lib.docview.FileNameFromPath(filepath),
1432 style = wx.OPEN
1433 )
1434 if findFile.ShowModal() == wx.ID_OK and findFile.GetPath():
1435 newpath = findFile.GetPath()
1436 else:
1437 newpath = None
1438 findFile.Destroy()
1439 if newpath:
1440 # update Project Model with new location
1441 project = self._GetItemProject(item)
1442 project.RemoveFile(filepath)
1443 project.AddFile(newpath)
1444 filepath = newpath
1445
1446 doc = self.GetDocumentManager().CreateDocument(filepath, wx.lib.docview.DOC_SILENT)
1447 if not doc:
1448 shortFilename = self._treeCtrl.GetItemText(item)
1449 if shortFilename.endswith(".agp"):
1450 projItem = self._GetProjectItem(shortFilename=shortFilename)
1451 self._treeCtrl.UnselectAll()
1452 if not self._treeCtrl.IsExpanded(projItem):
1453 self._treeCtrl.Expand(projItem)
1454 if not self._treeCtrl.IsVisible(projItem):
1455 self._treeCtrl.EnsureVisible(projItem)
1456 if not self._treeCtrl.IsSelected(projItem):
1457 self._treeCtrl.SelectItem(projItem)
1458
1459 except IOError, (code, message):
1460 msgTitle = wx.GetApp().GetAppName()
1461 if not msgTitle:
1462 msgTitle = _("File Error")
1463 wx.MessageBox("Could not open '%s'." % wx.lib.docview.FileNameFromPath(filepath),
1464 msgTitle,
1465 wx.OK | wx.ICON_EXCLAMATION,
1466 self.GetFrame())
1467
1468
1469 #----------------------------------------------------------------------------
1470 # Convenience methods
1471 #----------------------------------------------------------------------------
1472
1473 def _HasFiles(self):
1474 if not self._treeCtrl:
1475 return False
1476 return self._treeCtrl.GetCount() > 1 # 1 item = root item, don't count as having files
1477
1478
1479 def _HasSelection(self):
1480 if not self._treeCtrl:
1481 return False
1482
1483 items = self._treeCtrl.GetSelections()
1484 if items:
1485 return True
1486
1487 return False
1488
1489
1490 def _HasFilesSelected(self):
1491 if not self._treeCtrl:
1492 return False
1493 items = self._treeCtrl.GetSelections()
1494 if not items:
1495 return False
1496 for item in items:
1497 if not self._IsItemFile(item):
1498 return False
1499 return True
1500
1501
1502 def _MakeProjectName(self, project):
1503 return project.GetPrintableName()
1504
1505
1506 # Return the tree item for a project
1507 def _GetProjectItem(self, project=None, shortFilename=None):
1508 rootItem = self._treeCtrl.GetRootItem()
1509 (child, cookie) = self._treeCtrl.GetFirstChild(rootItem)
1510 while child.IsOk():
1511 if project:
1512 if self._treeCtrl.GetProjectDoc(child) == project:
1513 return child
1514 elif shortFilename:
1515 if self._treeCtrl.GetItemText(child) == shortFilename:
1516 return child
1517 (child, cookie) = self._treeCtrl.GetNextChild(rootItem, cookie)
1518 return None
1519
1520
1521 # Returns the project for an item, either for a project item or a file that is part of a project
1522 def _GetItemProject(self, item):
1523 if self._IsItemRoot(item):
1524 return None
1525 if self._IsItemProject(item):
1526 return self._treeCtrl.GetProjectDoc(item)
1527 if self._IsItemFile(item):
1528 return self._treeCtrl.GetProjectDoc(self._treeCtrl.GetItemParent(item))
1529 return None
1530
1531
1532 def _GetItemFile(self, item):
1533 if self._IsItemFile(item):
1534 return self._treeCtrl.GetLongFilename(item)
1535 else:
1536 return None
1537
1538
1539 def _GetFileItem(self, shortFileName = None, longFileName = None):
1540 """ Returns the tree item for a file given the short (display) or long (fullpath) file name. """
1541
1542 rootItem = self._treeCtrl.GetRootItem()
1543 (project, cookie) = self._treeCtrl.GetFirstChild(rootItem)
1544 while project.IsOk():
1545 (child, cookie2) = self._treeCtrl.GetFirstChild(project)
1546 while child.IsOk():
1547 if shortFileName:
1548 if self._treeCtrl.GetItemText(child) == shortFileName:
1549 return child
1550 else:
1551 if self._treeCtrl.GetLongFilename(child) == longFileName:
1552 return child
1553 (child, cookie2) = self._treeCtrl.GetNextChild(project, cookie2)
1554 (project, cookie) = self._treeCtrl.GetNextChild(rootItem, cookie)
1555 return None
1556
1557
1558 def _IsItemRoot(self, item):
1559 return item == self._treeCtrl.GetRootItem()
1560
1561
1562 def _IsItemProject(self, item):
1563 return self._treeCtrl.GetProjectDoc(item) != None
1564
1565
1566 def _IsItemFile(self, item):
1567 return self._treeCtrl.GetProjectDoc(item) == None
1568
1569
1570 def _IsItemProcessModelFile(self, item):
1571 if ACTIVEGRID_BASE_IDE:
1572 return False
1573
1574 if self._IsItemFile(item):
1575 filename = self._treeCtrl.GetLongFilename(item)
1576 ext = None
1577 for template in self.GetDocumentManager().GetTemplates():
1578 if template.GetDocumentType() == ProcessModelEditor.ProcessModelDocument:
1579 ext = template.GetDefaultExtension()
1580 break;
1581 if not ext:
1582 return False
1583
1584 if filename.endswith(ext):
1585 return True
1586
1587 return False
1588
1589
1590 def _GetChildItems(self, parentItem):
1591 children = []
1592 (child, cookie) = self._treeCtrl.GetFirstChild(parentItem)
1593 while child.IsOk():
1594 children.append(child)
1595 (child, cookie) = self._treeCtrl.GetNextChild(parentItem, cookie)
1596 return children
1597
1598
1599
1600 class ProjectFileDropTarget(wx.FileDropTarget):
1601
1602 def __init__(self, view):
1603 wx.FileDropTarget.__init__(self)
1604 self._view = view
1605
1606
1607 def OnDropFiles(self, x, y, filenames):
1608 if self._view.DoSelectProject(x, y):
1609 self._view.DoAddFilesToProject(filenames)
1610 self._view.DoSelectFiles(filenames)
1611 return True
1612 return False
1613
1614
1615 def OnDragOver(self, x, y, default):
1616 if self._view.DoSelectProject(x,y):
1617 return wx.DragCopy
1618 return wx.DragNone
1619
1620
1621 class ProjectPropertiesDialog(wx.Dialog):
1622
1623
1624 def __init__(self, parent, filename):
1625 wx.Dialog.__init__(self, parent, -1, _("Project Properties"), size = (310, 330))
1626
1627 filePropertiesService = wx.GetApp().GetService(wx.lib.pydocview.FilePropertiesService)
1628
1629 notebook = wx.Notebook(self, -1)
1630 tab = wx.Panel(notebook, -1)
1631
1632 gridSizer = RowColSizer()
1633
1634 gridSizer.Add(wx.StaticText(tab, -1, _("Filename:")), flag=wx.RIGHT, border=HALF_SPACE, row=0, col=0)
1635 if os.path.isfile(filename):
1636 gridSizer.Add(wx.StaticText(tab, -1, os.path.split(filename)[1]), row=0, col=1)
1637
1638 gridSizer.Add(wx.StaticText(tab, -1, _("Location:")), flag=wx.RIGHT, border=HALF_SPACE, row=1, col=0)
1639 gridSizer.Add(wx.StaticText(tab, -1, filePropertiesService.chopPath(os.path.split(filename)[0])), flag=wx.BOTTOM, border=SPACE, row=1, col=1)
1640
1641 gridSizer.Add(wx.StaticText(tab, -1, _("Size:")), flag=wx.RIGHT, border=HALF_SPACE, row=2, col=0)
1642 gridSizer.Add(wx.StaticText(tab, -1, str(os.path.getsize(filename)) + ' ' + _("bytes")), row=2, col=1)
1643
1644 lineSizer = wx.BoxSizer(wx.VERTICAL) # let the line expand horizontally without vertical expansion
1645 lineSizer.Add(wx.StaticLine(tab, -1, size = (10,-1)), 0, wx.EXPAND)
1646 gridSizer.Add(lineSizer, flag=wx.EXPAND|wx.ALIGN_CENTER_VERTICAL|wx.TOP, border=HALF_SPACE, row=3, col=0, colspan=2)
1647
1648 gridSizer.Add(wx.StaticText(tab, -1, _("Created:")), flag=wx.RIGHT, border=HALF_SPACE, row=4, col=0)
1649 gridSizer.Add(wx.StaticText(tab, -1, time.ctime(os.path.getctime(filename))), row=4, col=1)
1650
1651 gridSizer.Add(wx.StaticText(tab, -1, _("Modified:")), flag=wx.RIGHT, border=HALF_SPACE, row=5, col=0)
1652 gridSizer.Add(wx.StaticText(tab, -1, time.ctime(os.path.getmtime(filename))), row=5, col=1)
1653
1654 gridSizer.Add(wx.StaticText(tab, -1, _("Accessed:")), flag=wx.RIGHT, border=HALF_SPACE, row=6, col=0)
1655 gridSizer.Add(wx.StaticText(tab, -1, time.ctime(os.path.getatime(filename))), row=6, col=1)
1656
1657 else:
1658 gridSizer.Add(wx.StaticText(tab, -1, os.path.split(filename)[1] + ' ' + _("[new project]")), row=0, col=1)
1659
1660 # add a border around the inside of the tab
1661 spacerGrid = wx.BoxSizer(wx.VERTICAL)
1662 spacerGrid.Add(gridSizer, 0, wx.ALL, SPACE);
1663 tab.SetSizer(spacerGrid)
1664 notebook.AddPage(tab, _("General"))
1665 if wx.Platform == "__WXMSW__":
1666 notebook.SetPageSize((310,200))
1667
1668 sizer = wx.BoxSizer(wx.VERTICAL)
1669 sizer.Add(notebook, 0, wx.ALL | wx.EXPAND, SPACE)
1670 sizer.Add(self.CreateButtonSizer(wx.OK), 0, wx.ALIGN_RIGHT | wx.RIGHT | wx.BOTTOM, HALF_SPACE)
1671
1672 self.SetSizer(sizer)
1673 sizer.Fit(self)
1674 self.Layout()
1675
1676
1677 class ProjectOptionsPanel(wx.Panel):
1678
1679
1680 def __init__(self, parent, id):
1681 wx.Panel.__init__(self, parent, id)
1682 self._useSashMessageShown = False
1683 config = wx.ConfigBase_Get()
1684 self._projSaveDocsCheckBox = wx.CheckBox(self, -1, _("Remember open projects"))
1685 self._projSaveDocsCheckBox.SetValue(config.ReadInt("ProjectSaveDocs", True))
1686 projectBorderSizer = wx.BoxSizer(wx.VERTICAL)
1687 projectSizer = wx.BoxSizer(wx.VERTICAL)
1688 projectSizer.Add(self._projSaveDocsCheckBox, 0, wx.ALL, HALF_SPACE)
1689 if not ACTIVEGRID_BASE_IDE:
1690 self._projShowWelcomeCheckBox = wx.CheckBox(self, -1, _("Show Welcome Dialog"))
1691 self._projShowWelcomeCheckBox.SetValue(config.ReadInt("RunWelcomeDialog", True))
1692 projectSizer.Add(self._projShowWelcomeCheckBox, 0, wx.ALL, HALF_SPACE)
1693 projectBorderSizer.Add(projectSizer, 0, wx.ALL, SPACE)
1694 self.SetSizer(projectBorderSizer)
1695 self.Layout()
1696 parent.AddPage(self, _("Project"))
1697
1698 def OnUseSashSelect(self, event):
1699 if not self._useSashMessageShown:
1700 msgTitle = wx.GetApp().GetAppName()
1701 if not msgTitle:
1702 msgTitle = _("Document Options")
1703 wx.MessageBox("Project window embedded mode changes will not appear until the application is restarted.",
1704 msgTitle,
1705 wx.OK | wx.ICON_INFORMATION,
1706 self.GetParent())
1707 self._useSashMessageShown = True
1708
1709
1710 def OnOK(self, optionsDialog):
1711 config = wx.ConfigBase_Get()
1712 config.WriteInt("ProjectSaveDocs", self._projSaveDocsCheckBox.GetValue())
1713 if not ACTIVEGRID_BASE_IDE:
1714 config.WriteInt("RunWelcomeDialog", self._projShowWelcomeCheckBox.GetValue())
1715
1716
1717 class ProjectService(Service.Service):
1718
1719 #----------------------------------------------------------------------------
1720 # Constants
1721 #----------------------------------------------------------------------------
1722 SHOW_WINDOW = wx.NewId() # keep this line for each subclass, need unique ID for each Service
1723 RUNPM_ID = wx.NewId()
1724 RUN_SELECTED_PM_ID = wx.NewId()
1725 RUN_CURRENT_PM_ID = wx.NewId()
1726 ADD_FILES_TO_PROJECT_ID = wx.NewId()
1727 ADD_CURRENT_FILE_TO_PROJECT_ID = wx.NewId()
1728 RENAME_ID = wx.NewId()
1729 OPEN_SELECTION_ID = wx.NewId()
1730 REMOVE_FROM_PROJECT = wx.NewId()
1731 DELETE_FILE_ID = wx.NewId()
1732 ADD_ALL_FILES_TO_PROJECT_ID = wx.NewId()
1733
1734
1735 #----------------------------------------------------------------------------
1736 # Overridden methods
1737 #----------------------------------------------------------------------------
1738
1739 def __init__(self, serviceName, embeddedWindowLocation = wx.lib.pydocview.EMBEDDED_WINDOW_LEFT):
1740 Service.Service.__init__(self, serviceName, embeddedWindowLocation)
1741 self._runHandlers = []
1742 self._suppressOpenProjectMessages = False
1743
1744
1745 def _CreateView(self):
1746 return ProjectView(self)
1747
1748
1749 def ShowWindow(self, show = True):
1750 """ Force showing of saved projects on opening, otherwise empty Project Window is disconcerting for user """
1751 Service.Service.ShowWindow(self, show)
1752
1753 if show:
1754 project = self.GetView().GetDocument()
1755 if not project:
1756 self.OpenSavedProjects()
1757
1758
1759 #----------------------------------------------------------------------------
1760 # Service specific methods
1761 #----------------------------------------------------------------------------
1762
1763 def GetSuppressOpenProjectMessages(self):
1764 return self._suppressOpenProjectMessages
1765
1766
1767 def SetSuppressOpenProjectMessages(self, suppressOpenProjectMessages):
1768 self._suppressOpenProjectMessages = suppressOpenProjectMessages
1769
1770
1771 def GetRunHandlers(self):
1772 return self._runHandlers
1773
1774
1775 def AddRunHandler(self, runHandler):
1776 self._runHandlers.append(runHandler)
1777
1778
1779 def RemoveRunHandler(self, runHandler):
1780 self._runHandlers.remove(runHandler)
1781
1782
1783 def InstallControls(self, frame, menuBar = None, toolBar = None, statusBar = None, document = None):
1784 Service.Service.InstallControls(self, frame, menuBar, toolBar, statusBar, document)
1785
1786 projectMenu = wx.Menu()
1787
1788 ## accelTable = wx.AcceleratorTable([
1789 ## eval(_("wx.ACCEL_CTRL, ord('R'), ProjectService.RUN_ID"))
1790 ## ])
1791 ## frame.SetAcceleratorTable(accelTable)
1792 isProjectDocument = document and document.GetDocumentTemplate().GetDocumentType() == ProjectDocument
1793 if wx.GetApp().IsMDI() or isProjectDocument:
1794 if not menuBar.FindItemById(ProjectService.ADD_FILES_TO_PROJECT_ID):
1795 projectMenu.Append(ProjectService.ADD_FILES_TO_PROJECT_ID, _("Add &Files to Project..."), _("Adds a document to the current project"))
1796 wx.EVT_MENU(frame, ProjectService.ADD_FILES_TO_PROJECT_ID, frame.ProcessEvent)
1797 wx.EVT_UPDATE_UI(frame, ProjectService.ADD_FILES_TO_PROJECT_ID, frame.ProcessUpdateUIEvent)
1798 if not menuBar.FindItemById(ProjectService.ADD_ALL_FILES_TO_PROJECT_ID):
1799 projectMenu.Append(ProjectService.ADD_ALL_FILES_TO_PROJECT_ID, _("Add Directory Files to Project..."), _("Adds a directory's documents to the current project"))
1800 wx.EVT_MENU(frame, ProjectService.ADD_ALL_FILES_TO_PROJECT_ID, frame.ProcessEvent)
1801 wx.EVT_UPDATE_UI(frame, ProjectService.ADD_ALL_FILES_TO_PROJECT_ID, frame.ProcessUpdateUIEvent)
1802 if not menuBar.FindItemById(ProjectService.ADD_CURRENT_FILE_TO_PROJECT_ID):
1803 projectMenu.Append(ProjectService.ADD_CURRENT_FILE_TO_PROJECT_ID, _("&Add Active File to Project..."), _("Adds the active document to a project"))
1804 wx.EVT_MENU(frame, ProjectService.ADD_CURRENT_FILE_TO_PROJECT_ID, frame.ProcessEvent)
1805 wx.EVT_UPDATE_UI(frame, ProjectService.ADD_CURRENT_FILE_TO_PROJECT_ID, frame.ProcessUpdateUIEvent)
1806 viewMenuIndex = menuBar.FindMenu(_("&View"))
1807 menuBar.Insert(viewMenuIndex + 1, projectMenu, _("&Project"))
1808 editMenu = menuBar.GetMenu(menuBar.FindMenu(_("&Edit")))
1809 if not menuBar.FindItemById(ProjectService.RENAME_ID):
1810 editMenu.Append(ProjectService.RENAME_ID, _("&Rename"), _("Renames the active item"))
1811 wx.EVT_MENU(frame, ProjectService.RENAME_ID, frame.ProcessEvent)
1812 wx.EVT_UPDATE_UI(frame, ProjectService.RENAME_ID, frame.ProcessUpdateUIEvent)
1813 if not menuBar.FindItemById(ProjectService.DELETE_FILE_ID):
1814 editMenu.Append(ProjectService.DELETE_FILE_ID, _("Delete File"), _("Delete the file from the project and file system."))
1815 wx.EVT_MENU(frame, ProjectService.DELETE_FILE_ID, frame.ProcessEvent)
1816 wx.EVT_UPDATE_UI(frame, ProjectService.DELETE_FILE_ID, frame.ProcessUpdateUIEvent)
1817
1818 return True
1819
1820
1821 def OnCloseFrame(self, event):
1822 if not self.GetView():
1823 return True
1824
1825 if wx.GetApp().IsMDI():
1826 # close all non-project documents first
1827 for document in self.GetDocumentManager().GetDocuments()[:]: # Cloning list to make sure we go through all docs even as they are deleted
1828 if document.GetDocumentTemplate().GetDocumentType() != ProjectDocument:
1829 if not self.GetDocumentManager().CloseDocument(document, False):
1830 return False
1831
1832 # write project config afterwards because user may change filenames on closing of new documents
1833 self.GetView().WriteProjectConfig() # Called onCloseWindow in all of the other services but needed to be factored out for ProjectService since it is called elsewhere
1834
1835 # close all project documents after closing other documents
1836 # because user may save a new document with a new name or cancel closing a document
1837 for document in self.GetDocumentManager().GetDocuments()[:]: # Cloning list to make sure we go through all docs even as they are deleted
1838 if document.GetDocumentTemplate().GetDocumentType() == ProjectDocument:
1839 if not document.OnSaveModified():
1840 return False
1841
1842 # This is called when any SDI frame is closed, so need to check if message window is closing or some other window
1843 elif self.GetView() == event.GetEventObject().GetView():
1844 self.SetView(None)
1845 return True
1846
1847
1848 #----------------------------------------------------------------------------
1849 # Event Processing Methods
1850 #----------------------------------------------------------------------------
1851
1852 def ProcessEventBeforeWindows(self, event):
1853 id = event.GetId()
1854
1855 if id == wx.ID_CLOSE_ALL:
1856 self.OnFileCloseAll(event)
1857 return True
1858
1859 elif id == wx.ID_CLOSE:
1860 document = self.GetDocumentManager().GetCurrentDocument()
1861 if document and document.GetDocumentTemplate().GetDocumentType() == ProjectDocument:
1862 self.OnProjectClose(event)
1863 return True
1864 else:
1865 return False
1866 return False
1867
1868
1869 def ProcessUpdateUIEventBeforeWindows(self, event):
1870 id = event.GetId()
1871
1872 if id == wx.ID_CLOSE_ALL:
1873 for document in self.GetDocumentManager().GetDocuments():
1874 if document.GetDocumentTemplate().GetDocumentType() != ProjectDocument:
1875 event.Enable(True)
1876 return True
1877
1878 event.Enable(False)
1879 return True
1880
1881 elif id == wx.ID_CLOSE:
1882 document = self.GetDocumentManager().GetCurrentDocument()
1883 if document and document.GetDocumentTemplate().GetDocumentType() == ProjectDocument:
1884 projectFilenames = self.GetView().GetSelectedProjects()
1885 if projectFilenames and len(projectFilenames):
1886 event.Enable(True)
1887 else:
1888 event.Enable(False)
1889 return True
1890
1891 return False
1892
1893
1894 def ProcessEvent(self, event):
1895 if Service.Service.ProcessEvent(self, event):
1896 return True
1897
1898 id = event.GetId()
1899 if id == ProjectService.RUN_SELECTED_PM_ID:
1900 self.OnRunProcessModel(event, runSelected=True)
1901 return True
1902 elif id == ProjectService.RUN_CURRENT_PM_ID:
1903 self.OnRunProcessModel(event, runCurrentFile=True)
1904 return True
1905 elif id == ProjectService.ADD_CURRENT_FILE_TO_PROJECT_ID:
1906 self.OnAddCurrentFileToProject(event)
1907 return True
1908 elif id == wx.lib.pydocview.FilePropertiesService.PROPERTIES_ID:
1909 if self.GetView():
1910 return self.GetView().ProcessEvent(event)
1911 else:
1912 return False
1913 else:
1914 return False
1915
1916
1917 def ProcessUpdateUIEvent(self, event):
1918 if Service.Service.ProcessUpdateUIEvent(self, event):
1919 return True
1920
1921 id = event.GetId()
1922 if (id == ProjectService.RUNPM_ID
1923 or id == ProjectService.RUN_SELECTED_PM_ID
1924 or id == ProjectService.RUN_CURRENT_PM_ID):
1925 event.Enable(self._HasOpenedProjects() and self._HasProcessModel())
1926 return True
1927 elif id == ProjectService.ADD_CURRENT_FILE_TO_PROJECT_ID:
1928 event.Enable(self._CanAddCurrentFileToProject())
1929 return True
1930 elif (id == ProjectService.ADD_FILES_TO_PROJECT_ID
1931 or id == ProjectService.ADD_ALL_FILES_TO_PROJECT_ID
1932 or id == ProjectService.RENAME_ID
1933 or id == ProjectService.OPEN_SELECTION_ID
1934 or id == ProjectService.DELETE_FILE_ID):
1935 event.Enable(False)
1936 return True
1937 elif id == wx.lib.pydocview.FilePropertiesService.PROPERTIES_ID:
1938 if self.GetView():
1939 return self.GetView().ProcessUpdateUIEvent(event)
1940 else:
1941 return False
1942 else:
1943 return False
1944
1945
1946 def OnRunProcessModel(self, event, runSelected=False, runCurrentFile=False):
1947 project = self.GetView().GetDocument()
1948
1949 if project:
1950 ext = None
1951 for template in self.GetDocumentManager().GetTemplates():
1952 if template.GetDocumentType() == ProcessModelEditor.ProcessModelDocument:
1953 ext = template.GetDefaultExtension()
1954 break;
1955 if not ext:
1956 return
1957
1958 files = filter(lambda f: f.endswith(ext), project.GetFiles())
1959 if not files:
1960 return
1961
1962 docs = wx.GetApp().GetDocumentManager().GetDocuments()
1963 for doc in docs:
1964 if doc.GetFilename() in files and doc.GetDocumentTemplate().GetDocumentType() == ProcessModelEditor.ProcessModelDocument:
1965 if not doc.GetProcessModel().beginProcess:
1966 wx.MessageBox(_("Cannot run process. No begin action found."), _("Run Process"))
1967 return
1968
1969 filesModified = False
1970 for doc in docs:
1971 if doc.IsModified():
1972 filesModified = True
1973 break
1974 if filesModified:
1975 frame = self.GetView().GetFrame()
1976 yesNoMsg = wx.MessageDialog(frame,
1977 _("Files have been modified. Process may not reflect your current changes.\n\nWould you like to save all files before running?"),
1978 _("Run Process"),
1979 wx.YES_NO|wx.ICON_QUESTION
1980 )
1981 if yesNoMsg.ShowModal() == wx.ID_YES:
1982 wx.GetTopLevelParent(frame).OnFileSaveAll(None)
1983
1984 if runCurrentFile:
1985 fileToRun = self.GetDocumentManager().GetCurrentDocument().GetFilename()
1986 elif runSelected:
1987 fileToRun = self.GetView().GetSelectedFile()
1988 elif len(files) > 1:
1989 files.sort(lambda a, b: cmp(os.path.basename(a).lower(), os.path.basename(b).lower()))
1990 strings = map(lambda file: os.path.basename(file), files)
1991 res = wx.GetSingleChoiceIndex(_("Select a process to run:"),
1992 _("Run"),
1993 strings,
1994 project.GetFirstView()._GetParentFrame())
1995 if res == -1:
1996 return
1997 fileToRun = files[res]
1998 else:
1999 fileToRun = files[0]
2000
2001 self.RunProcessModel(fileToRun)
2002
2003
2004 def RunProcessModel(self, fileToRun):
2005 for runHandler in self.GetRunHandlers():
2006 if runHandler.RunProjectFile(fileToRun):
2007 return
2008 os.system('"' + fileToRun + '"')
2009
2010
2011 def _HasProcessModel(self):
2012 project = self.GetView().GetDocument()
2013
2014 if project:
2015 ext = None
2016 for template in self.GetDocumentManager().GetTemplates():
2017 if template.GetDocumentType() == ProcessModelEditor.ProcessModelDocument:
2018 ext = template.GetDefaultExtension()
2019 break;
2020 if not ext:
2021 return False
2022
2023 files = filter(lambda f: f.endswith(ext), project.GetFiles())
2024 if not files:
2025 return False
2026
2027 if len(files):
2028 return True
2029
2030 return False
2031
2032
2033 def _HasOpenedProjects(self):
2034 for document in self.GetDocumentManager().GetDocuments():
2035 if document.GetDocumentTemplate().GetDocumentType() == ProjectDocument:
2036 return True
2037 return False
2038
2039
2040 def _HasCurrentFile(self):
2041 currentDoc = self.GetDocumentManager().GetCurrentDocument()
2042 return currentDoc
2043
2044
2045 def _CanAddCurrentFileToProject(self):
2046 currentDoc = self.GetDocumentManager().GetCurrentDocument()
2047 if not currentDoc:
2048 return False
2049 if currentDoc.GetDocumentTemplate().GetDocumentType() == ProjectDocument:
2050 return False
2051 if not currentDoc._savedYet:
2052 return False
2053 for document in self.GetDocumentManager().GetDocuments():
2054 if document.GetDocumentTemplate().GetDocumentType() == ProjectDocument:
2055 return True
2056 return False # There are no documents open
2057
2058
2059 def GetFilesFromCurrentProject(self):
2060 view = self.GetView()
2061 if view:
2062 project = view.GetDocument()
2063 if project:
2064 return project.GetFiles()
2065 return None
2066
2067
2068 def GetCurrentProject(self):
2069 view = self.GetView()
2070 if view:
2071 return view.GetDocument()
2072 return None
2073
2074
2075 def FindProjectByFile(self, filename):
2076 for document in self.GetDocumentManager().GetDocuments():
2077 if document.GetDocumentTemplate().GetDocumentType() == ProjectDocument:
2078 if document.GetFilename() == filename:
2079 return document
2080 elif document.IsFileInProject(filename):
2081 return document
2082 return None
2083
2084
2085 def GetCurrentProjectNames(self):
2086 projects = []
2087 for document in self.GetDocumentManager().GetDocuments():
2088 if document.GetDocumentTemplate().GetDocumentType() == ProjectDocument:
2089 projects.append(document)
2090 if not projects:
2091 return
2092 projects.sort(lambda a, b: cmp(a.GetPrintableName().lower(), b.GetPrintableName().lower()))
2093 strings = map(lambda project: project.GetPrintableName(), projects)
2094 return strings
2095
2096
2097 def OnAddCurrentFileToProject(self, event):
2098 if not self._CanAddCurrentFileToProject():
2099 return
2100 projects = []
2101 for document in self.GetDocumentManager().GetDocuments():
2102 if document.GetDocumentTemplate().GetDocumentType() == ProjectDocument:
2103 projects.append(document)
2104 if not projects:
2105 return
2106 projects.sort(lambda a, b: cmp(a.GetPrintableName().lower(), b.GetPrintableName().lower()))
2107 strings = map(lambda project: project.GetPrintableName(), projects)
2108 res = wx.GetSingleChoiceIndex(_("Select a project to add the file to:"),
2109 _("Add to Project"),
2110 strings,
2111 self.GetDocumentManager().FindSuitableParent())
2112 if res == -1:
2113 return
2114 file = self.GetDocumentManager().GetCurrentDocument().GetFilename()
2115 projects[res].GetCommandProcessor().Submit(ProjectAddFilesCommand(projects[res], [file]))
2116 self.GetView().Activate(True) # after add, should put focus on project editor
2117
2118
2119 def OnProjectClose(self, event):
2120 projectFilenames = self.GetView().GetSelectedProjects()
2121 for filename in projectFilenames:
2122 doc = self.FindProjectByFile(filename)
2123 if doc:
2124 self.GetDocumentManager().CloseDocument(doc, False)
2125
2126
2127 def OnFileCloseAll(self, event):
2128 for document in self.GetDocumentManager().GetDocuments()[:]: # Cloning list to make sure we go through all docs even as they are deleted
2129 if document.GetDocumentTemplate().GetDocumentType() != ProjectDocument:
2130 if not self.GetDocumentManager().CloseDocument(document, False):
2131 return
2132 # document.DeleteAllViews() # Implicitly delete the document when the last view is removed
2133
2134
2135 def OpenSavedProjects(self):
2136 config = wx.ConfigBase_Get()
2137 openedDocs = False
2138 if config.ReadInt("ProjectSaveDocs", True):
2139 docString = config.Read("ProjectSavedDocs")
2140 if docString:
2141 doc = None
2142 for fileName in eval(docString):
2143 if isinstance(fileName, types.StringTypes):
2144 if os.path.exists(fileName):
2145 doc = self.GetDocumentManager().CreateDocument(fileName, wx.lib.docview.DOC_SILENT)
2146
2147 if doc:
2148 openedDocs = True
2149 expandedString = config.Read("ProjectExpandedSavedDocs")
2150 if expandedString:
2151 view = doc.GetFirstView()
2152 view.SetExpandedProjects(eval(expandedString))
2153 return openedDocs
2154
2155
2156 class ProjectEditorMoveCommand(wx.lib.docview.Command):
2157
2158 def __init__(self, view, newPositionItem, item):
2159 wx.lib.docview.Command.__init__(self, canUndo = True)
2160 self._view = view
2161 self._item = item
2162 self._file = view._treeCtrl.GetLongFilename(item)
2163 if view._IsItemFile(item):
2164 self._projectOld = view._GetItemProject(item)
2165 else: # view._IsItemProject(item):
2166 self._projectOld = None
2167 self._projectNew = view._GetItemProject(newPositionItem)
2168
2169
2170 def GetName(self):
2171 return _("Move File %s") % os.path.basename(self._file)
2172
2173
2174 def Do(self):
2175 if self._projectOld:
2176 self._projectOld.RemoveFile(self._file)
2177 if self._projectNew:
2178 self._projectNew.AddFile(self._file)
2179 return True
2180
2181
2182 def Undo(self):
2183 if self._projectNew:
2184 self._projectNew.RemoveFile(self._file)
2185 if self._projectOld:
2186 self._projectOld.AddFile(self._file)
2187 return True
2188
2189
2190 #----------------------------------------------------------------------------
2191 # Icon Bitmaps - generated by encode_bitmaps.py
2192 #----------------------------------------------------------------------------
2193 from wx import ImageFromStream, BitmapFromImage
2194 import cStringIO
2195
2196
2197 def getProjectData():
2198 return \
2199 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
2200 \x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
2201 \x00\x00[IDAT8\x8d\xc5\x93\xc1\n\xc00\x08C\x8d\xf6\xff\xffX\xb3Sa-\xf6`;:O\n\
2202 \x12\x1fj\x0059\t\xed\t\xc3\xc9pn\x0b\x88\x88@\rU\x81\xf6.\x18N\xa8aE\x92\rh\
2203 YC\x85\xa4D\x90\x91\xdc%\xf8w\x07+\xd1\xfbW\x98\xc5\x8f\t\x86W\xee\x93+\xbe\
2204 \xc0gn\xdc\x8d\x07\xab"<iG\x8e\xa9\r\x00\x00\x00\x00IEND\xaeB`\x82'
2205
2206 def getProjectBitmap():
2207 return BitmapFromImage(getProjectImage())
2208
2209 def getProjectImage():
2210 stream = cStringIO.StringIO(getProjectData())
2211 return ImageFromStream(stream)
2212
2213 def getProjectIcon():
2214 return wx.IconFromBitmap(getProjectBitmap())
2215
2216
2217 #----------------------------------------------------------------------------
2218
2219 def getBlankData():
2220 return \
2221 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\
2222 \x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\
2223 \x00\x00]IDAT8\x8d\xed\x931\x0e\xc00\x08\x03m\x92\xff\xff8q\x87\xb6C\x11\x89\
2224 \xa8X:\xd4\x13\x03:\x1b\x01\xa45T\xd4\xefBsh\xd7Hk\xdc\x02\x00@\x8a\x19$\xa1\
2225 9\x14A,\x95\xf3\x82G)\xd3\x00\xf24\xf7\x90\x1ev\x07\xee\x1e\xf4:\xc1J?\xe0\
2226 \x0b\x80\xc7\x1d\xf8\x1dg\xc4\xea7\x96G8\x00\xa8\x91\x19(\x85#P\x7f\x00\x00\
2227 \x00\x00IEND\xaeB`\x82'
2228
2229
2230 def getBlankBitmap():
2231 return BitmapFromImage(getBlankImage())
2232
2233 def getBlankImage():
2234 stream = cStringIO.StringIO(getBlankData())
2235 return ImageFromStream(stream)
2236
2237 def getBlankIcon():
2238 return wx.IconFromBitmap(getBlankBitmap())
2239