root/trunk/ide/Editor.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys
import os
import os.path
import keyword
import code
import inspect
import operator
import dabo
import dabo.dEvents as dEvents
from dabo.dLocalize import _
_Use_Subprocess = True
try:
    import subprocess
except ImportError:
    _Use_Subprocess = False
from dabo.lib.reportUtils import getTempFile
if __name__ == "__main__":
    dabo.ui.loadUI("wx")


class EditPageSplitter(dabo.ui.dSplitter):
    def __init__(self, *args, **kwargs):
        kwargs["createPanes"] = True
        super(EditPageSplitter, self).__init__(*args, **kwargs)
        self.ShowPanelSplitMenu = False

    def initProperties(self):
        self.Width = 250
        self.Height = 200
        self.MinimumPanelSize = 20

    def onSashDoubleClick(self, evt):
        evt.stop()
        
    def onContextMenu(self, evt):
        evt.stop()
        
    def onSashPositionChanged(self, evt):
        self.Parent.updateSashPos()



class EditorEditor(dabo.ui.dEditor):
    def addDroppedText(self, txt):
        curr = self.Value
        ss, se = self.SelectionStart, self.SelectionEnd
        self.Value = "%s%s%s" % (curr[:ss], txt, curr[se:])
        self.SelectionStart = ss
        self.SelectionEnd = ss + len(txt)
        
    
    def _getTextSource(self):
        return self.Form.getTextSource()



class EditorPage(dabo.ui.dPage):
    def initProperties(self):
        self.p = None
        self.outputText = ""
        self._outputSashExtra = self.Application.getUserSetting("editorform.outputSashExtra", 100)


    def afterInit(self):
        self.splitter = EditPageSplitter(self, Orientation="h")
        self.splitter.SashPosition = self.Height - self._outputSashExtra
        
        self.splitter.Panel1.Sizer = dabo.ui.dSizer()
        self.splitter.Panel2.Sizer = dabo.ui.dSizer()
    
        self.editor = EditorEditor(self.splitter.Panel1)
        self.editor.UseBookmarks = True
        self.editor.page = self
        self.output = dabo.ui.dEditBox(self.splitter.Panel2)
        self.output.ReadOnly = True
        
        self.splitter.Panel1.Sizer.append1x(self.editor)
        self.splitter.Panel2.Sizer.append1x(self.output)
        
        self.Sizer = dabo.ui.dSizer()
        self.Sizer.append1x(self.splitter)
                
        self.updateTimer = dabo.ui.callEvery(1000, self.outputUpdate)
        
        self.layout()
        
        self.editor.setFocus()
        self.editor.bindEvent(dEvents.TitleChanged, self.onTitleChanged)
        self.editor.bindEvent(dEvents.MouseRightClick, self.Form.onEditorRightClick)
        # Set up the file drop target
        self.editor.DroppedFileHandler = self.Form
        # Set up the text drop target
        ### NOTE: currently we can only have text or file drops, not both
        #self.editor.DroppedTextHandler = self.Form
        # Update Hide/Show of output. Default to hidden
        self.showOutput(self.Application.getUserSetting("visibleOutput", False))
        # Set the initial title
        dabo.ui.callAfter(self.onTitleChanged, None)
        dabo.ui.callAfter(self.splitter._setOrientation, "h") #Its weird without this, self.splitter._constructed is not true
        dabo.ui.callAfter(self.updateSashPos)


    def onResize(self, evt):
        self.splitter.SashPosition = self.Height - self._outputSashExtra

        
    def updateSashPos(self):
        if self.splitter.SashPosition > 0:
            self._outputSashExtra = self.Height - self.splitter.SashPosition
        self.Application.setUserSetting("editorform.outputSashExtra", self._outputSashExtra)
        
    
    def outputUpdate(self):
        if self and self.p:
            #need a nonblocking way of getting stdout and stderr
            self.outputText = self.outputText + self.p.stdout.read() + self.p.stderr.read()
            if not self.p.poll() is None:
                self.p = None
            self.output.Value = self.outputText
    
    
    def showOutput(self, show):
        self.splitter.Split = show
    
    
    def onTitleChanged(self, evt):
        title = self.editor._title
        self.Caption = title
        self.Form.onTitleChanged(evt)
    
    
    def onPageEnter(self, evt):
        self.editor.setFocus()
    
    
    def onPageLeave(self, evt):
        self.editor.setInactive()
    
    
    def onDestroy(self, evt):
        dabo.ui.callAfter(self.Form.onTitleChanged, evt)


    def _getPathInfo(self):
        try:
            ret = self.editor._fileName
        except:
            ret = ""
        return ret


    PathInfo = property(_getPathInfo, None, None,
            _("Path to the file being edited  (str)") )
            
        

class EditorPageFrame(dabo.ui.dPageFrame):
    def beforeInit(self):
        self.PageClass = EditorPage
    
    
    def getTextSource(self):
        txt = []
        for pg in self.Pages:
            txt.append(pg.editor.Value)
        return " ".join(txt)


    def checkChanges(self, closing=False):
        """Cycle through the pages, and if any contain unsaved changes,
        ask the user if they should be saved. If they cancel, immediately 
        stop and return False. If they say yes, save the contents. Unless 
        they cancel, close each page.
        """
        ret = True
        for pg in self.Pages[::-1]:
            ed = pg.editor
            ret = ed.checkChangesAndContinue()
            if not ret:
                break
            elif closing:
                self.PageCount -= 1
        return ret
    
    
    def findEditor(self, pth, selectIt=False):
        """Returns the editor that is editing the specified file. If there
        is no matching editor, returns None. If selectIt is True, makes that
        editor the active editor.
        """
        ret = None
        for pg in self.Pages:
            if pg.editor._fileName == pth:
                ret = pg.editor
                if selectIt:
                    self.SelectedPage = pg
        return ret

        
    def editFile(self, pth, selectIt=False):
        ret = self.findEditor(pth, selectIt)
        if ret is None:
            # Create a new page
            pg = self.getBlankPage(True)
            try:
                fileTarget = pg.editor.openFile(pth)
                if fileTarget:
                    self.SelectedPage = pg
                    ret = pg
            except:
                dabo.ui.callAfter(self.removePage, pg)
                ret = None
        return ret
            
            
    def getBlankPage(self, create=False):
        """Returns the first page that is not associated with a file,
        and which has not been modified. If no such page exists, and
        the 'create' parameter is True, a new blank page is created 
        and returned. Otherwise, returns None.
        """
        ret = None
        for pg in self.Pages:
            ed = pg.editor
            if ed._title.strip() == ed._newFileName.strip():
                ret = pg
                break
        if ret is None and create:
            self.PageCount += 1
            ret = self.Pages[-1]
        return ret
        
    
    def closeEditor(self, ed=None, checkChanges=True):
        if ed is None:
            ed = self.SelectedPage.editor
        if checkChanges:
            ret = ed.checkChangesAndContinue()
        else:
            ret = True
        if ret is not False:
            self.removePage(ed.page)
        return ret
        
            
    def newEditor(self):
        ret = self.getBlankPage(True)
        self.SelectedPage = ret
        return ret


    def selectByCaption(self, cap):
        pgs = [pg for pg in self.Pages
                if pg.Caption == cap]
        if pgs:
            pg = pgs[0]
        else:
            dabo.errorLog.write(_("No matching page for %s") % cap)
            return
        self.SelectedPage = pg
        pg.editor.setFocus()
    
    
    def edFocus(self):
        self.SelectedPage.editor.setFocus()
    
        
    def _getCurrentEditor(self):
        try:
            return self.SelectedPage.editor
        except:
            return None
            
            
    def _getTitle(self):
        sp = self.SelectedPage
        try:
            ret = sp.PathInfo
            if sp.editor.Modified:
                ret += " *"
        except:
            ret = ""
        return ret

    
    CurrentEditor = property(_getCurrentEditor, None, None,
            _("References the currently active editor  (dEditor)"))

    Title = property(_getTitle, None, None,
            _("Title of the active page  (str)") )
            
            

class EditorForm(dabo.ui.dForm):
    def __init__(self, *args, **kwargs):
        super(EditorForm, self).__init__(*args, **kwargs)
        
        
    def afterInit(self):
        # Set up the file drop target
        self.DroppedFileHandler = self
        pnl = dabo.ui.dPanel(self)
        self.Sizer.append1x(pnl)
        pnl.Sizer = dabo.ui.dSizer("v")
        self._lastPath = self.Application.getUserSetting("lastPath", os.getcwd())
        super(EditorForm, self).afterInit()
        self.Caption = _("Dabo Editor")
        self.funcButton = dabo.ui.dImage(pnl, ScaleMode="Clip", Size=(22,22))
        self.funcButton.Picture = dabo.ui.imageFromData(funcButtonData())
        self.funcButton.bindEvent(dEvents.MouseLeftDown, self.onFuncButton)
        self.bmkButton = dabo.ui.dImage(pnl, ScaleMode="Clip", Size=(22,22))
        self.bmkButton.Picture = dabo.ui.imageFromData(bmkButtonData())
        self.bmkButton.bindEvent(dEvents.MouseLeftDown, self.onBmkButton)

        self.prntButton = dabo.ui.dBitmapButton(pnl, Size=(22,22))
        self.prntButton.Picture = "print"
        self.prntButton.bindEvent(dEvents.Hit, self.onPrint)
        
        self.lexSelector = dabo.ui.dDropdownList(pnl, ValueMode="String")
        self.lexSelector.bindEvent(dEvents.Hit, self.onLexSelect)

        btnSizer = dabo.ui.dSizer("H", DefaultSpacing=4)
        btnSizer.append(self.funcButton)
        btnSizer.append(self.bmkButton)
        btnSizer.append(self.prntButton)
        btnSizer.appendSpacer(10, proportion=1)
        lbl = dabo.ui.dLabel(pnl, Caption=_("Language:"))
        if not self.Application.Platform.lower() == "win":
            lbl.FontSize -= 2
            self.lexSelector.FontSize -= 2
        btnSizer.append(lbl, valign="middle")
        btnSizer.append(self.lexSelector, valign="middle")

        pnl.Sizer.append(btnSizer, "x", border=4)       
        
        self.pgfEditor = EditorPageFrame(pnl, TabPosition="Top")
        self.pgfEditor.bindEvent(dEvents.PageChanged, self.onEditorPageChanged)
        pnl.Sizer.append1x(self.pgfEditor)
        self.layout()
        self.fillMenu()
        dabo.ui.callAfter(self.showPage, 0)


    def showPage(self, pg):
        """Shows the specified page, if it exists."""
        try:
            self.pgfEditor.SelectedPage = pg
            self.pgfEditor.edFocus()
        except:
            pass


    def onPrint(self, evt):
        self.CurrentEditor.onPrint()


    def onActivate(self, evt):
        """Check the files to see if any have been updated on disk."""
        self.checkForUpdatedFiles()


    def checkForUpdatedFiles(self):
        """If any file being edited has not been modified, and there is a more recent version
        on disk, update the file with the version on disk.
        """
        for pg in self.pgfEditor.Pages:
            ed = pg.editor
            if not ed.isChanged() and ed.checkForDiskUpdate():
                selpos = ed.SelectionPosition
                ed.openFile(ed._fileName)
                ed.SelectionPosition = selpos


    def onLexSelect(self, evt):
        self.CurrentEditor.Language = self.lexSelector.Value

        
    def onFuncButton(self, evt):
        evt.stop()
        flist = self.CurrentEditor.getFunctionList()
        pop = dabo.ui.dMenu()
        for nm, pos, iscls in flist:
            prompt = nm
            if not iscls:
                prompt = " - %s" % nm
            itm = pop.append(prompt, OnHit=self.onFunctionPop)
            itm.textPosition = pos
        self.showContextMenu(pop)
        del pop
    
    
    def onFunctionPop(self, evt):
        ed = self.CurrentEditor
        pos = evt.menuItem.textPosition
        currLine = ed.LineNumber
        newLine = ed.getLineFromPosition(pos)
        if newLine > currLine:
            ed.moveToEnd()
        ed.ensureLineVisible(newLine)
        ed.LineNumber = newLine
        nextLinePos = ed.getPositionFromLine(newLine+1)
        ed.SelectionPosition = (pos, nextLinePos-1)
    
    
    def onIdle(self, evt):
        ed = self.CurrentEditor
        if ed:
            self.StatusText = "Line: %s, Col: %s" % (ed.LineNumber, ed.Column)
    
    
    def getTextSource(self):
        return self.pgfEditor.getTextSource()


    def onEditorRightClick(self, evt):
        ed = self.CurrentEditor
        pos = evt.mousePosition
        pp = ed.getPositionFromXY(pos)
        if pp < 0:
            # They clicked outside of the text area of the line. Find
            # a position just to the right of the margin
            lpos = ed.getMarginWidth()
            pp = ed.getPositionFromXY(lpos, pos[1])
        if pp < 0:
            # This is a totally blank line. Nothing can be done
            return
        ln = ed.getLineFromPosition(pp)
        ed.LineNumber = ln
        self.onBmkButton(evt)
        
                
    def onBmkButton(self, evt):
        evt.stop()
        ed = self.CurrentEditor
        bmkList = ed.getBookmarkList()
        pop = dabo.ui.dMenu()
        currBmk = ed.getCurrentLineBookmark()
        if not currBmk:
            pop.append(_("Set Bookmark..."), OnHit=self.onSetBmk)
        else:
            pop.append(_("Clear Bookmark..."), OnHit=self.onClearBmk)
        if bmkList:
            pop.append(_("Clear All Bookmarks"), OnHit=self.onClearAllBmk)
            pop.appendSeparator()
            for nm in bmkList:
                itm = pop.append(nm, OnHit=self.onBookmarkPop)
        self.showContextMenu(pop)
        del pop
    
    
    def onBookmarkPop(self, evt):
        """Navigate to the chosen bookmark."""
        self.CurrentEditor.findBookmark(evt.prompt)
    
    
    def onSetBmk(self, evt):
        """Need to ask the user for a name for this bookmark."""
        nm = dabo.ui.getString(message=_("Name for this bookmark:"), 
                caption=_("New Bookmark"))
        if not nm:
            # User canceled
            return
        ed = self.CurrentEditor
        if nm in ed.getBookmarkList():
            msg = _("There is already a bookmark named '%s'. Creating a new bookmark "
                    "with the same name will delete the old one. Are you sure you want "
                    "to do this?") % nm
            if not dabo.ui.areYouSure(message=msg, title=_("Duplicate Name"),
                    defaultNo=True, cancelButton=False):
                return
        self.CurrentEditor.setBookmark(nm)
        

    def onClearBmk(self, evt):
        """Clear the current bookmark."""
        ed = self.CurrentEditor
        bmk = ed.getCurrentLineBookmark()
        if bmk:
            ed.clearBookmark(bmk)
    
    
    def onClearAllBmk(self, evt):
        """Remove all the bookmarks."""
        self.CurrentEditor.clearAllBookmarks()
        

    def onEditorPageChanged(self, evt):
        self.checkForUpdatedFiles()
        self.onTitleChanged(evt)
        self.setCheckedMenus()
        self.updateLex()
    
    
    def updateLex(self):
        if self.CurrentEditor:
            if not self.lexSelector.Choices:
                self.lexSelector.Choices = self.CurrentEditor.getAvailableLanguages()
            self.lexSelector.Value = self.CurrentEditor.Language
    
    
    def setCheckedMenus(self):
        ed = self.CurrentEditor
        if ed is None:
            self._autoAutoItem.Checked = self._wrapItem.Checked = self._synColorItem.Checked = False
        else:
            self._autoAutoItem.Checked = ed.AutoAutoComplete
            self._wrapItem.Checked = ed.WordWrap
            self._synColorItem.Checked = ed.SyntaxColoring
        self._showOutItem.Checked = self.Application.getUserSetting("visibleOutput", False)
        
        
    def beforeClose(self, evt):
        ret= self.pgfEditor.checkChanges(closing=True)
        return ret


    def processDroppedFiles(self, filelist):
        """Try to open each file up in an editor tab."""
        self.openRecursively(filelist)


    def processDroppedText(self, txt):
        """Add the text to the current editor."""
        self.CurrentEditor.addDroppedText(txt)
    
    
    def openRecursively(self, filelist):
        if isinstance(filelist, basestring):
            # Individual file passed
            filelist = [filelist]
        for ff in filelist:
            if os.path.isdir(ff):
                for fname in os.listdir(ff):
                    self.openRecursively(os.path.join(ff, fname))
            else:
                if os.path.isfile(ff):
                    self.openFile(ff, justReportErrors=True)


    def onDocumentationHint(self, evt):
        # Eventually, a separate IDE window can optionally display help contents
        # for the object. For now, just print the longdoc to the infolog.
        dabo.infoLog.write(_("Documentation Hint received:\n\n%s") % evt.EventData["longDoc"])


    def onTitleChanged(self, evt):
        if self and self.pgfEditor:
            self.Caption = _("Dabo Editor: %s") % self.pgfEditor.Title