Exemple #1
0
class FakeEditor(pyzo.core.baseTextCtrl.BaseTextCtrl):
    """This "fake" editor emits a signal when
    the user clicks on a word with a token :
    a click on the word "class" emits with arg "syntax.keyword".
    
    It may be improved by adding text with specific token
    like Editor.text which are not present by default
    """

    tokenClicked = QtCore.Signal(str)

    def __init__(self, text=""):
        super().__init__()

        # set parser to enable syntaxic coloration
        self.setParser("python3")
        self.setReadOnly(False)
        self.setLongLineIndicatorPosition(30)
        self.setPlainText(SAMPLE)

    def mousePressEvent(self, event):
        super().mousePressEvent(event)

        # get the text position of the click
        pos = self.textCursor().columnNumber()
        tokens = self.textCursor().block().userData().tokens

        # Find the token which contains the click pos
        for tok in tokens:
            if tok.start <= pos <= tok.end:
                self.tokenClicked.emit(tok.description.key)
                break
Exemple #2
0
class WorkspaceProxy(QtCore.QObject):
    """ WorkspaceProxy
    
    A proxy class to handle the asynchonous behaviour of getting information
    from the shell. The workspace tool asks for a certain name, and this
    class notifies when new data is available using a qt signal.
    
    """

    haveNewData = QtCore.Signal()

    def __init__(self):
        QtCore.QObject.__init__(self)

        # Variables
        self._variables = []

        # Element to get more info of
        self._name = ''

        # Bind to events
        pyzo.shells.currentShellChanged.connect(self.onCurrentShellChanged)
        pyzo.shells.currentShellStateChanged.connect(
            self.onCurrentShellStateChanged)

        # Initialize
        self.onCurrentShellStateChanged()

    def addNamePart(self, part):
        """ addNamePart(part)
        Add a part to the name.
        """
        parts = splitName(self._name)
        parts.append(part)
        self.setName(joinName(parts))

    def setName(self, name):
        """ setName(name)
        Set the name that we want to know more of.
        """
        self._name = name

        shell = pyzo.shells.getCurrentShell()
        if shell:
            future = shell._request.dir2(self._name)
            future.add_done_callback(self.processResponse)

    def goUp(self):
        """ goUp()
        Cut the last part off the name.
        """
        parts = splitName(self._name)
        if parts:
            parts.pop()
        self.setName(joinName(parts))

    def onCurrentShellChanged(self):
        """ onCurrentShellChanged()
        When no shell is selected now, update this. In all other cases,
        the onCurrentShellStateChange will be fired too.
        """
        shell = pyzo.shells.getCurrentShell()
        if not shell:
            self._variables = []
            self.haveNewData.emit()

    def onCurrentShellStateChanged(self):
        """ onCurrentShellStateChanged()
        Do a request for information!
        """
        shell = pyzo.shells.getCurrentShell()
        if not shell:
            # Should never happen I think, but just to be sure
            self._variables = []
        elif shell._state.lower() != 'busy':
            future = shell._request.dir2(self._name)
            future.add_done_callback(self.processResponse)

    def processResponse(self, future):
        """ processResponse(response)
        We got a response, update our list and notify the tree.
        """

        response = []

        # Process future
        if future.cancelled():
            pass  #print('Introspect cancelled') # No living kernel
        elif future.exception():
            print('Introspect-queryDoc-exception: ', future.exception())
        else:
            response = future.result()

        self._variables = response
        self.haveNewData.emit()
Exemple #3
0
class CompactTabBar(QtWidgets.QTabBar):
    """ CompactTabBar(parent, *args, padding=(4,4,6,6), preventEqualTexts=True)
    
    Tab bar corresponcing to the CompactTabWidget.
    
    With the "padding" argument the padding of the tabs can be chosen.
    It should be an integer, or a 4 element tuple specifying the padding
    for top, bottom, left, right. When a tab has a button,
    the padding is the space between button and text.
    
    With preventEqualTexts to True, will reduce the amount of eliding if
    two tabs have (partly) the same name, so that they can always be
    distinguished.
    
    """

    # Add signal to be notified of double clicks on tabs
    tabDoubleClicked = QtCore.Signal(int)
    barDoubleClicked = QtCore.Signal()

    def __init__(self, *args, padding=(4, 4, 6, 6), preventEqualTexts=True):
        QtWidgets.QTabBar.__init__(self, *args)

        # Put tab widget in document mode
        self.setDocumentMode(True)

        # Widget needs to draw its background (otherwise Mac has a dark bg)
        self.setDrawBase(False)
        if sys.platform == 'darwin':
            self.setAutoFillBackground(True)

        # Set whether we want to prevent eliding for names that start the same.
        self._preventEqualTexts = preventEqualTexts

        # Allow moving tabs around
        self.setMovable(True)

        # Get padding
        if isinstance(padding, (int, float)):
            padding = padding, padding, padding, padding
        elif isinstance(padding, (tuple, list)):
            pass
        else:
            raise ValueError('Invalid value for padding.')

        # Set style sheet
        stylesheet = STYLESHEET
        stylesheet = stylesheet.replace('PADDING_TOP', str(padding[0]))
        stylesheet = stylesheet.replace('PADDING_BOTTOM', str(padding[1]))
        stylesheet = stylesheet.replace('PADDING_LEFT', str(padding[2]))
        stylesheet = stylesheet.replace('PADDING_RIGHT', str(padding[3]))
        self.setStyleSheet(stylesheet)

        # We do our own eliding
        self.setElideMode(QtCore.Qt.ElideNone)

        # Make tabs wider if there's plenty space?
        self.setExpanding(False)

        # If there's not enough space, use scroll buttons
        self.setUsesScrollButtons(True)

        # When a tab is removed, select previous
        self.setSelectionBehaviorOnRemove(self.SelectPreviousTab)

        # Init alignment parameters
        self._alignWidth = MIN_NAME_WIDTH  # Width in characters
        self._alignWidthIsReducing = False  # Whether in process of reducing

        # Create timer for aligning
        self._alignTimer = QtCore.QTimer(self)
        self._alignTimer.setInterval(10)
        self._alignTimer.setSingleShot(True)
        self._alignTimer.timeout.connect(self._alignRecursive)

    def _compactTabBarData(self, i):
        """ _compactTabBarData(i)
        
        Get the underlying tab data for tab i. Only for internal use.
        
        """

        # Get current TabData instance
        tabData = QtWidgets.QTabBar.tabData(self, i)
        if (tabData is not None) and hasattr(tabData, 'toPyObject'):
            tabData = tabData.toPyObject()  # Older version of Qt

        # If none, make it as good as we can
        if not tabData:
            name = str(QtWidgets.QTabBar.tabText(self, i))
            tabData = TabData(name)
            QtWidgets.QTabBar.setTabData(self, i, tabData)

        # Done
        return tabData

    ## Overload a few methods

    def mouseDoubleClickEvent(self, event):
        i = self.tabAt(event.pos())
        if i == -1:
            # There was no tab under the cursor
            self.barDoubleClicked.emit()
        else:
            # Tab was double clicked
            self.tabDoubleClicked.emit(i)

    def mousePressEvent(self, event):
        if event.button() == QtCore.Qt.MiddleButton:
            i = self.tabAt(event.pos())
            if i >= 0:
                self.parent().tabCloseRequested.emit(i)
                return
        super().mousePressEvent(event)

    def setTabData(self, i, data):
        """ setTabData(i, data)
        
        Set the given object at the tab with index 1.
        
        """
        # Get underlying python instance
        tabData = self._compactTabBarData(i)

        # Attach given data
        tabData.data = data

    def tabData(self, i):
        """ tabData(i)
        
        Get the tab data at item i. Always returns a Python object.
        
        """

        # Get underlying python instance
        tabData = self._compactTabBarData(i)

        # Return stored data
        return tabData.data

    def setTabText(self, i, text):
        """ setTabText(i, text)
        
        Set the text for tab i.
        
        """
        tabData = self._compactTabBarData(i)
        if text != tabData.name:
            tabData.name = text
            self.alignTabs()

    def tabText(self, i):
        """ tabText(i)
        
        Get the title of the tab at index i.
        
        """
        tabData = self._compactTabBarData(i)
        return tabData.name

    ## Overload events and protected functions

    def tabInserted(self, i):
        QtWidgets.QTabBar.tabInserted(self, i)

        # Is called when a tab is inserted

        # Get given name and store
        name = str(QtWidgets.QTabBar.tabText(self, i))
        tabData = TabData(name)
        QtWidgets.QTabBar.setTabData(self, i, tabData)

        # Update
        self.alignTabs()

    def tabRemoved(self, i):
        QtWidgets.QTabBar.tabRemoved(self, i)

        # Update
        self.alignTabs()

    def resizeEvent(self, event):
        QtWidgets.QTabBar.resizeEvent(self, event)
        self.alignTabs()

    def showEvent(self, event):
        QtWidgets.QTabBar.showEvent(self, event)
        self.alignTabs()

    ## For aligning

    def alignTabs(self):
        """ alignTabs()
        
        Align the tab items. Their names are ellided if required so that
        all tabs fit on the tab bar if possible. When there is too little
        space, the QTabBar will kick in and draw scroll arrows.
        
        """

        # Set name widths correct (in case new names were added)
        self._setMaxWidthOfAllItems()

        # Start alignment process
        self._alignWidthIsReducing = False
        self._alignTimer.start()

    def _alignRecursive(self):
        """ _alignRecursive()
        
        Recursive alignment of the items. The alignment process
        should be initiated from alignTabs().
        
        """

        # Only if visible
        if not self.isVisible():
            return

        # Get tab bar and number of items
        N = self.count()

        # Get right edge of last tab and left edge of corner widget
        pos1 = self.tabRect(0).topLeft()
        pos2 = self.tabRect(N - 1).topRight()
        cornerWidget = self.parent().cornerWidget()
        if cornerWidget:
            pos3 = cornerWidget.pos()
        else:
            pos3 = QtCore.QPoint(self.width(), 0)
        x1 = pos1.x()
        x2 = pos2.x()
        x3 = pos3.x()
        alignMargin = x3 - (x2 - x1) - 3  # Must be positive (has margin)

        # Are the tabs too wide?
        if alignMargin < 0:
            # Tabs extend beyond corner widget

            # Reduce width then
            self._alignWidth -= 1
            self._alignWidth = max(self._alignWidth, MIN_NAME_WIDTH)

            # Apply
            self._setMaxWidthOfAllItems()
            self._alignWidthIsReducing = True

            # Try again if there's still room for reduction
            if self._alignWidth > MIN_NAME_WIDTH:
                self._alignTimer.start()

        elif alignMargin > 10 and not self._alignWidthIsReducing:
            # Gap between tabs and corner widget is a bit large

            # Increase width then
            self._alignWidth += 1
            self._alignWidth = min(self._alignWidth, MAX_NAME_WIDTH)

            # Apply
            itemsElided = self._setMaxWidthOfAllItems()

            # Try again if there's still room for increment
            if itemsElided and self._alignWidth < MAX_NAME_WIDTH:
                self._alignTimer.start()
                #self._alignTimer.timeout.emit()

        else:
            pass  # margin is good

    def _getAllNames(self):
        """ _getAllNames()
        
        Get a list of all (full) tab names.
        
        """
        return [self._compactTabBarData(i).name for i in range(self.count())]

    def _setMaxWidthOfAllItems(self):
        """ _setMaxWidthOfAllItems()
        
        Sets the maximum width of all items now, by eliding the names.
        Returns whether any items were elided.
        
        """

        # Prepare for measuring font sizes
        font = self.font()
        metrics = QtGui.QFontMetrics(font)

        # Get whether an item was reduced in size
        itemReduced = False

        for i in range(self.count()):

            # Get width
            w = self._alignWidth

            # Get name
            name = name0 = self._compactTabBarData(i).name

            # Check if we can reduce the name size, correct w if necessary
            if ((w + 1) < len(name0)) and self._preventEqualTexts:

                # Increase w untill there are no names that start the same
                allNames = self._getAllNames()
                hasSimilarNames = True
                diff = 2
                w -= 1
                while hasSimilarNames and w < len(name0):
                    w += 1
                    w2 = w - (diff - 1)
                    shortName = name[:w2]
                    similarnames = [n for n in allNames if n[:w2] == shortName]
                    hasSimilarNames = len(similarnames) > 1

            # Check again, with corrected w
            if (w + 1) < len(name0):
                name = name[:w] + ELLIPSIS
                itemReduced = True

            # Set text now
            QtWidgets.QTabBar.setTabText(self, i, name)

        # Done
        return itemReduced
Exemple #4
0
class PyzoEditor(BaseTextCtrl):

    # called when dirty changed or filename changed, etc
    somethingChanged = QtCore.Signal()

    def __init__(self, parent, **kwds):
        super().__init__(parent, showLineNumbers=True, **kwds)

        # Init filename and name
        self._filename = ''
        self._name = '<TMP>'

        # View settings
        self.setShowWhitespace(pyzo.config.view.showWhitespace)
        #TODO: self.setViewWrapSymbols(view.showWrapSymbols)
        self.setShowLineEndings(pyzo.config.view.showLineEndings)
        self.setShowIndentationGuides(pyzo.config.view.showIndentationGuides)
        #
        self.setWrap(bool(pyzo.config.view.wrap))
        self.setHighlightCurrentLine(pyzo.config.view.highlightCurrentLine)
        self.setLongLineIndicatorPosition(pyzo.config.view.edgeColumn)
        self.setHighlightMatchingBracket(
            pyzo.config.view.highlightMatchingBracket)
        #TODO: self.setFolding( int(view.codeFolding)*5 )
        # bracematch is set in baseTextCtrl, since it also applies to shells
        # dito for zoom and tabWidth

        # Set line endings to default
        self.lineEndings = pyzo.config.settings.defaultLineEndings

        # Set encoding to default
        self.encoding = 'UTF-8'

        # Modification time to test file change
        self._modifyTime = 0

        self.modificationChanged.connect(self._onModificationChanged)

        # To see whether the doc has changed to update the parser.
        self.textChanged.connect(self._onModified)

        # This timer is used to hide the marker that shows which code is executed
        self._showRunCursorTimer = QtCore.QTimer()

        # Add context menu (the offset is to prevent accidental auto-clicking)
        self._menu = EditorContextMenu(self)
        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.customContextMenuRequested.connect(lambda p: self._menu.popup(
            self.mapToGlobal(p) + QtCore.QPoint(0, 3)))

    ## Properties

    @property
    def name(self):
        return self._name

    @property
    def filename(self):
        return self._filename

    @property
    def lineEndings(self):
        """
        Line-endings style of this file. Setter accepts machine-readable (e.g. '\r') and human-readable (e.g. 'CR') input
        """
        return self._lineEndings

    @lineEndings.setter
    def lineEndings(self, value):
        if value in ('\r', '\n', '\r\n'):
            self._lineEndings = value
            return
        try:
            self._lineEndings = {'CR': '\r', 'LF': '\n', 'CRLF': '\r\n'}[value]
        except KeyError:
            raise ValueError('Invalid line endings style %r' % value)

    @property
    def lineEndingsHumanReadable(self):
        """
        Current line-endings style, human readable (e.g. 'CR')
        """
        return {'\r': 'CR', '\n': 'LF', '\r\n': 'CRLF'}[self.lineEndings]

    @property
    def encoding(self):
        """ Encoding used to convert the text of this file to bytes.
        """
        return self._encoding

    @encoding.setter
    def encoding(self, value):
        # Test given value, correct name if it exists
        try:
            c = codecs.lookup(value)
            value = c.name
        except Exception:
            value = codecs.lookup('UTF-8').name
        # Store
        self._encoding = value

    ##

    def justifyText(self):
        """ Overloaded version of justifyText to make it use our
        configurable justificationwidth.
        """
        super().justifyText(pyzo.config.settings.justificationWidth)

    def showRunCursor(self, cursor):
        """
        Momentarily highlight a piece of code to show that this is being executed
        """

        extraSelection = QtWidgets.QTextEdit.ExtraSelection()
        extraSelection.cursor = cursor
        extraSelection.format.setBackground(QtCore.Qt.gray)
        self.setExtraSelections([extraSelection])

        self._showRunCursorTimer.singleShot(
            200, lambda: self.setExtraSelections([]))

    def id(self):
        """ Get an id of this editor. This is the filename,
        or for tmp files, the name. """
        if self._filename:
            return self._filename
        else:
            return self._name

    def focusInEvent(self, event):
        """ Test whether the file has been changed 'behind our back'
        """
        # Act normally to the focus event
        BaseTextCtrl.focusInEvent(self, event)
        # Test file change
        self.testWhetherFileWasChanged()

    def testWhetherFileWasChanged(self):
        """ testWhetherFileWasChanged()
        Test to see whether the file was changed outside our backs,
        and let the user decide what to do.
        Returns True if it was changed.
        """

        # get the path
        path = self._filename
        if not os.path.isfile(path):
            # file is deleted from the outside
            return

        # test the modification time...
        mtime = os.path.getmtime(path)
        if mtime != self._modifyTime:

            # ask user
            dlg = QtWidgets.QMessageBox(self)
            dlg.setWindowTitle('File was changed')
            dlg.setText("File has been modified outside of the editor:\n" +
                        self._filename)
            dlg.setInformativeText("Do you want to reload?")
            t = dlg.addButton("Reload", QtWidgets.QMessageBox.AcceptRole)  #0
            dlg.addButton("Keep this version",
                          QtWidgets.QMessageBox.RejectRole)  #1
            dlg.setDefaultButton(t)

            # whatever the result, we will reset the modified time
            self._modifyTime = os.path.getmtime(path)

            # get result and act
            result = dlg.exec_()
            if result == QtWidgets.QMessageBox.AcceptRole:
                self.reload()
            else:
                pass  # when cancelled or explicitly said, do nothing

            # Return that indeed the file was changes
            return True

    def _onModificationChanged(self, changed):
        """Handler for the modificationChanged signal. Emit somethingChanged
        for the editorStack to update the modification notice."""
        self.somethingChanged.emit()

    def _onModified(self):
        pyzo.parser.parseThis(self)

    def dragMoveEvent(self, event):
        """ Otherwise cursor can get stuck.
        https://bitbucket.org/iep-project/iep/issue/252
        https://qt-project.org/forums/viewthread/3180
        """
        if event.mimeData().hasUrls():
            event.acceptProposedAction()
        else:
            BaseTextCtrl.dropEvent(self, event)

    def dropEvent(self, event):
        """ Drop files in the list. """
        if event.mimeData().hasUrls():
            # file: let the editorstack do the work.
            pyzo.editors.dropEvent(event)
        else:
            # text: act normal
            BaseTextCtrl.dropEvent(self, event)

    def showEvent(self, event=None):
        """ Capture show event to change title. """
        # Act normally
        if event:
            BaseTextCtrl.showEvent(self, event)

        # Make parser update
        pyzo.parser.parseThis(self)

    def setTitleInMainWindow(self):
        """ set the title  text in the main window to show filename. """

        # compose title
        name, path = self._name, self._filename
        if path:
            pyzo.main.setMainTitle(path)
        else:
            pyzo.main.setMainTitle(name)

    def save(self, filename=None):
        """ Save the file. No checking is done. """

        # get filename
        if filename is None:
            filename = self._filename
        if not filename:
            raise ValueError("No filename specified, and no filename known.")

        # Test whether it was changed without us knowing. If so, dont save now.
        if self.testWhetherFileWasChanged():
            return

        # Get text and remember where we are
        text = self.toPlainText()
        cursor = self.textCursor()
        linenr = cursor.blockNumber() + 1
        index = cursor.positionInBlock()
        scroll = self.verticalScrollBar().value()

        # Convert line endings (optionally remove trailing whitespace
        if pyzo.config.settings.removeTrailingWhitespaceWhenSaving:
            lines = [line.rstrip() for line in text.split('\n')]
            if lines[-1]:
                lines.append('')  # Ensure the file ends in an empty line
            text = self.lineEndings.join(lines)
            self.setPlainText(text)
            # Go back to where we were
            cursor = self.textCursor()
            cursor.movePosition(cursor.Start)  # move to begin of the document
            cursor.movePosition(cursor.NextBlock,
                                n=linenr - 1)  # n blocks down
            index = min(index, cursor.block().length() - 1)
            cursor.movePosition(cursor.Right, n=index)  # n chars right
            self.setTextCursor(cursor)
            self.verticalScrollBar().setValue(scroll)
        else:
            text = text.replace('\n', self.lineEndings)

        # Make bytes
        bb = text.encode(self.encoding)

        # Store
        f = open(filename, 'wb')
        try:
            f.write(bb)
        finally:
            f.close()

        # Update stats
        self._filename = normalizePath(filename)
        self._name = os.path.split(self._filename)[1]
        self.document().setModified(False)
        self._modifyTime = os.path.getmtime(self._filename)

        # update title (in case of a rename)
        self.setTitleInMainWindow()

        # allow item to update its texts (no need: onModifiedChanged does this)
        #self.somethingChanged.emit()

    def reload(self):
        """ Reload text using the self._filename.
        We do not have a load method; we first try to load the file
        and only when we succeed create an editor to show it in...
        This method is only for reloading in case the file was changed
        outside of the editor. """

        # We can only load if the filename is known
        if not self._filename:
            return
        filename = self._filename

        # Remember where we are
        cursor = self.textCursor()
        linenr = cursor.blockNumber() + 1

        # Load file (as bytes)
        with open(filename, 'rb') as f:
            bb = f.read()

        # Convert to text
        text = bb.decode('UTF-8')

        # Process line endings (before setting the text)
        self.lineEndings = determineLineEnding(text)

        # Set text
        self.setPlainText(text)
        self.document().setModified(False)

        # Go where we were (approximately)
        self.gotoLine(linenr)

    def deleteLines(self):
        cursor = self.textCursor()
        # Find start and end of selection
        start = cursor.selectionStart()
        end = cursor.selectionEnd()
        # Expand selection: from start of first block to start of next block
        cursor.setPosition(start)
        cursor.movePosition(cursor.StartOfBlock)
        cursor.setPosition(end, cursor.KeepAnchor)
        cursor.movePosition(cursor.NextBlock, cursor.KeepAnchor)

        cursor.removeSelectedText()

    def duplicateLines(self):
        cursor = self.textCursor()
        # Find start and end of selection
        start = cursor.selectionStart()
        end = cursor.selectionEnd()
        # Expand selection: from start of first block to start of next block
        cursor.setPosition(start)
        cursor.movePosition(cursor.StartOfBlock)
        cursor.setPosition(end, cursor.KeepAnchor)
        cursor.movePosition(cursor.NextBlock, cursor.KeepAnchor)

        text = cursor.selectedText()
        cursor.setPosition(start)
        cursor.movePosition(cursor.StartOfBlock)
        cursor.insertText(text)

    def commentCode(self):
        """
        Comment the lines that are currently selected
        """
        indents = []

        def getIndent(cursor):
            text = cursor.block().text().rstrip()
            if text:
                indents.append(len(text) - len(text.lstrip()))

        def commentBlock(cursor):
            cursor.setPosition(cursor.block().position() + minindent)
            cursor.insertText('# ')

        self.doForSelectedBlocks(getIndent)
        minindent = min(indents) if indents else 0
        self.doForSelectedBlocks(commentBlock)

    def uncommentCode(self):
        """
        Uncomment the lines that are currently selected
        """

        #TODO: this should not be applied to lines that are part of a multi-line string

        #Define the uncomment function to be applied to all blocks
        def uncommentBlock(cursor):
            """
            Find the first # on the line; if there is just whitespace before it,
            remove the # and if it is followed by a space remove the space, too
            """
            text = cursor.block().text()
            commentStart = text.find('#')
            if commentStart == -1:
                return  #No comment on this line
            if text[:commentStart].strip() != '':
                return  #Text before the #
            #Move the cursor to the beginning of the comment
            cursor.setPosition(cursor.block().position() + commentStart)
            cursor.deleteChar()
            if text[commentStart:].startswith('# '):
                cursor.deleteChar()

        #Apply this function to all blocks
        self.doForSelectedBlocks(uncommentBlock)

    def gotoDef(self):
        """
        Goto the definition for the word under the cursor
        """

        # Get name of object to go to
        cursor = self.textCursor()
        if not cursor.hasSelection():
            cursor.select(cursor.WordUnderCursor)
        word = cursor.selection().toPlainText()

        # Send the open command to the shell
        s = pyzo.shells.getCurrentShell()
        if s is not None:
            if word and word.isidentifier():
                s.executeCommand('open %s\n' % word)
            else:
                s.write('Invalid identifier %r\n' % word)

    ## Introspection processing methods

    def processCallTip(self, cto):
        """ Processes a calltip request using a CallTipObject instance.
        """
        # Try using buffer first
        if cto.tryUsingBuffer():
            return

        # Try obtaining calltip from the source
        sig = pyzo.parser.getFictiveSignature(cto.name, self, True)
        if sig:
            # Done
            cto.finish(sig)
        else:
            # Try the shell
            shell = pyzo.shells.getCurrentShell()
            if shell:
                shell.processCallTip(cto)

    def processAutoComp(self, aco):
        """ Processes an autocomp request using an AutoCompObject instance.
        """

        # Try using buffer first
        if aco.tryUsingBuffer():
            return

        # Init name to poll by remote process (can be changed!)
        nameForShell = aco.name

        # Get normal fictive namespace
        fictiveNS = pyzo.parser.getFictiveNameSpace(self)
        fictiveNS = set(fictiveNS)

        # Add names
        if not aco.name:
            # "root" names
            aco.addNames(fictiveNS)
            # imports
            importNames, importLines = pyzo.parser.getFictiveImports(self)
            aco.addNames(importNames)
        else:
            # Prepare list of class names to check out
            classNames = [aco.name]
            handleSelf = True
            # Unroll supers
            while classNames:
                className = classNames.pop(0)
                if not className:
                    continue
                if handleSelf or (className in fictiveNS):
                    # Only the self list (only first iter)
                    fictiveClass = pyzo.parser.getFictiveClass(
                        className, self, handleSelf)
                    handleSelf = False
                    if fictiveClass:
                        aco.addNames(fictiveClass.members)
                        classNames.extend(fictiveClass.supers)
                else:
                    nameForShell = className
                    break

        # If there's a shell, let it finish the autocompletion
        shell = pyzo.shells.getCurrentShell()
        if shell:
            aco.name = nameForShell  # might be the same or a base class
            shell.processAutoComp(aco)
        else:
            # Otherwise we finish it ourselves
            aco.finish()
Exemple #5
0
class CommandHistory(QtCore.QObject):
    """Keep track of a (global) history of commands.

    This kinda assumes Python commands, but should be easy enough to generalize.
    """

    max_commands = 2000

    command_added = QtCore.Signal(str)
    command_removed = QtCore.Signal(int)
    commands_reset = QtCore.Signal()

    def __init__(self, fname):
        super().__init__()
        self._commands = []
        self._fname = fname
        self._last_date = datetime.date(2000, 1, 1)
        self._load()

    def _load(self):
        """Load commands from file."""
        if not self._fname:
            return

        assert not self._commands

        try:
            filename = os.path.join(pyzo.appDataDir, self._fname)
            if not os.path.isfile(filename):
                with open(filename, "wb"):
                    pass

            # Load lines and add to commands
            lines = open(filename, "r", encoding="utf-8").read().splitlines()
            self._commands.extend(
                [line.rstrip() for line in lines[-self.max_commands :]]
            )

            # Resolve last date
            for c in reversed(lines):
                if c.startswith("# ==== "):
                    try:
                        c = c.split("====")[1].strip()
                        self._last_date = datetime.datetime.strptime(
                            c, "%Y-%m-%d"
                        ).date()
                        break
                    except Exception:
                        pass

        except Exception as e:
            print("An error occurred while loading the history: " + str(e))

    def save(self):
        """Save the commands to disk."""
        if not self._fname:
            return
        filename = os.path.join(pyzo.appDataDir, self._fname)
        try:
            with open(filename, "wt", encoding="utf-8") as f:
                f.write("\n".join(self._commands))
        except Exception:
            print("Could not save command history")

    def get_commands(self):
        """Get a list of all commands (latest last)."""
        return self._commands.copy()

    def append(self, command):
        """Add a command to the list."""
        command = command.rstrip()
        if not command:
            return

        # Add date?
        today = datetime.date.today()
        if today > self._last_date:
            self._last_date = today
            self._commands.append("# ==== " + today.strftime("%Y-%m-%d"))
            self.command_added.emit(self._commands[-1])

        # Clear it
        try:
            index = self._commands.index(command)
        except ValueError:
            pass
        else:
            self._commands.pop(index)
            self.command_removed.emit(index)

        # Append
        self._commands.append(command)
        self.command_added.emit(self._commands[-1])

        # Reset?
        if len(self._commands) > self.max_commands:
            self._commands[: self.max_commands // 2] = []
            self.commands_reset.emit()

    def pop(self, index):
        """Remove a command by index."""
        self._commands.pop(index)
        self.command_removed.emit(index)

    def find_starting_with(self, firstpart, n=1):
        """Find the nth (1-based) command that starts with firstpart, or None."""
        count = 0
        for c in reversed(self._commands):
            if c.startswith(firstpart):
                count += 1
                if count >= n:
                    return c
        return None

    def find_all(self, needle):
        """Find all commands that contain the given text. In order
        of being used.
        """
        commands = []
        for c in reversed(self._commands):
            if needle in c:
                commands.append(c)
        return commands
Exemple #6
0
class ToolManager(QtCore.QObject):
    """ Manages the tools. """

    # This signal indicates a change in the loaded tools
    toolInstanceChange = QtCore.Signal()

    def __init__(self, parent=None):
        QtCore.QObject.__init__(self, parent)

        # list of ToolDescription instances
        self._toolInfo = None
        self._activeTools = {}

    def loadToolInfo(self):
        """ (re)load the tool information. 
        """
        # Get paths to load files from
        toolDir1 = os.path.join(pyzo.pyzoDir, 'tools')
        toolDir2 = os.path.join(pyzo.appDataDir, 'tools')

        # Create list of tool files
        toolfiles = []
        for toolDir in [toolDir1, toolDir2]:
            tmp = [os.path.join(toolDir, f) for f in os.listdir(toolDir)]
            toolfiles.extend(tmp)

        # Note: we do not use the code below anymore, since even the frozen
        # app makes use of the .py files.
#         # Get list of files, also when we're in a zip file.
#         i = tooldir.find('.zip')
#         if i>0:
#             # Get list of files from zipfile
#             tooldir = tooldir[:i+4]
#             import zipfile
#             z = zipfile.ZipFile(tooldir)
#             toolfiles = [os.path.split(i)[1] for i in z.namelist()
#                         if i.startswith('visvis') and i.count('functions')]
#         else:
#             # Get list of files from file system
#             toolfiles = os.listdir(tooldir)

# Iterate over tool modules
        newlist = []
        for file in toolfiles:
            modulePath = file

            # Check
            if os.path.isdir(file):
                file = os.path.join(file, '__init__.py')  # A package perhaps
                if not os.path.isfile(file):
                    continue
            elif file.endswith('__.py') or not file.endswith('.py'):
                continue
            elif file.endswith('pyzoFileBrowser.py'):
                # Skip old file browser (the file can be there from a previous install)
                continue

            #
            toolName = ""
            toolSummary = ""
            # read file to find name or summary
            linecount = 0
            for line in open(file, encoding='utf-8'):
                linecount += 1
                if linecount > 50:
                    break
                if line.startswith("tool_name"):
                    i = line.find("=")
                    if i < 0: continue
                    line = line.rstrip("\n").rstrip("\r")
                    line = line[i + 1:].strip(" ")
                    toolName = line.strip("'").strip('"')
                elif line.startswith("tool_summary"):
                    i = line.find("=")
                    if i < 0: continue
                    line = line.rstrip("\n").rstrip("\r")
                    line = line[i + 1:].strip(" ")
                    toolSummary = line.strip("'").strip('"')
                else:
                    pass

            # Add stuff
            tmp = ToolDescription(modulePath, toolName, toolSummary)
            newlist.append(tmp)

        # Store and return
        self._toolInfo = sorted(newlist, key=lambda x: x.id)
        self.updateToolInstances()
        return self._toolInfo

    def updateToolInstances(self):
        """ Make tool instances up to date, so that it can be seen what
        tools are now active. """
        for toolDes in self.getToolInfo():
            if toolDes.id in self._activeTools:
                toolDes.instance = self._activeTools[toolDes.id]
            else:
                toolDes.instance = None

        # Emit update signal
        self.toolInstanceChange.emit()

    def getToolInfo(self):
        """ Like loadToolInfo(), but use buffered instance if available.
        """
        if self._toolInfo is None:
            self.loadToolInfo()
        return self._toolInfo

    def getToolClass(self, toolId):
        """ Get the class of the tool.
        It will import (and reload) the module and get the class.
        Some checks are performed, like whether the class inherits 
        from QWidget.
        Returns the class or None if failed...
        """

        # Make sure we have the info
        if self._toolInfo is None:
            self.loadToolInfo()

        # Get module name and path
        for toolDes in self._toolInfo:
            if toolDes.id == toolId:
                moduleName = toolDes.moduleName
                modulePath = toolDes.modulePath
                break
        else:
            print("WARNING: could not find module for tool", repr(toolId))
            return None

        # Remove from sys.modules, to force the module to reload
        for key in [key for key in sys.modules]:
            if key and key.startswith('pyzo.tools.' + moduleName):
                del sys.modules[key]

        # Load module
        try:
            m_file, m_fname, m_des = imp.find_module(
                moduleName, [os.path.dirname(modulePath)])
            mod = imp.load_module('pyzo.tools.' + moduleName, m_file, m_fname,
                                  m_des)
        except Exception as why:
            print("Invalid tool " + toolId + ":", why)
            return None

        # Is the expected class present?
        className = ""
        for member in dir(mod):
            if member.lower() == toolId:
                className = member
                break
        else:
            print("Invalid tool, Classname must match module name '%s'!" %
                  toolId)
            return None

        # Does it inherit from QWidget?
        plug = mod.__dict__[className]
        if not (isinstance(plug, type) and issubclass(plug, QtGui.QWidget)):
            print("Invalid tool, tool class must inherit from QWidget!")
            return None

        # Succes!
        return plug

    def loadTool(self, toolId, splitWith=None):
        """ Load a tool by creating a dock widget containing the tool widget.
        """

        # A tool id should always be lower case
        toolId = toolId.lower()

        # Close old one
        if toolId in self._activeTools:
            old = self._activeTools[toolId].widget()
            self._activeTools[toolId].setWidget(QtGui.QWidget(pyzo.main))
            if old:
                old.close()
                old.deleteLater()

        # Get tool class (returns None on failure)
        toolClass = self.getToolClass(toolId)
        if toolClass is None:
            return

        # Already loaded? reload!
        if toolId in self._activeTools:
            self._activeTools[toolId].reload(toolClass)
            return

        # Obtain name from buffered list of names
        for toolDes in self._toolInfo:
            if toolDes.id == toolId:
                name = toolDes.name
                break
        else:
            name = toolId

        # Make sure there is a config entry for this tool
        if not hasattr(pyzo.config.tools, toolId):
            pyzo.config.tools[toolId] = ssdf.new()

        # Create dock widget and add in the main window
        dock = ToolDockWidget(pyzo.main, self)
        dock.setTool(toolId, name, toolClass)

        if splitWith and splitWith in self._activeTools:
            otherDock = self._activeTools[splitWith]
            pyzo.main.splitDockWidget(otherDock, dock, QtCore.Qt.Horizontal)
        else:
            pyzo.main.addDockWidget(QtCore.Qt.RightDockWidgetArea, dock)

        # Add to list
        self._activeTools[toolId] = dock
        self.updateToolInstances()

    def reloadTools(self):
        """ Reload all tools. """
        for id in self.getLoadedTools():
            self.loadTool(id)

    def closeTool(self, toolId):
        """ Close the tool with specified id.
        """
        if toolId in self._activeTools:
            dock = self._activeTools[toolId]
            dock.close()

    def getTool(self, toolId):
        """ Get the tool widget instance, or None
        if not available. """
        if toolId in self._activeTools:
            return self._activeTools[toolId].widget()
        else:
            return None

    def onToolClose(self, toolId):
        # Remove from dict
        self._activeTools.pop(toolId, None)
        # Set instance to None
        self.updateToolInstances()

    def getLoadedTools(self):
        """ Get a list with id's of loaded tools. """
        tmp = []
        for toolDes in self.getToolInfo():
            if toolDes.id in self._activeTools:
                tmp.append(toolDes.id)
        return tmp
Exemple #7
0
class Installer(QtWidgets.QDialog):
    
    lineFromStdOut = QtCore.Signal(str)
    
    def __init__(self, parent=None):
        QtWidgets.QDialog.__init__(self, parent)
        self.setWindowTitle('Install miniconda')
        self.setModal(True)
        self.resize(500, 500)
        
        text = translate('bootstrapconda', 'This will download and install miniconda on your computer.')
        
        self._label = QtWidgets.QLabel(text, self)
        
        self._scipystack = QtWidgets.QCheckBox(translate('bootstrapconda', 'Also install scientific packages'), self)
        self._scipystack.setChecked(True)
        self._path = QtWidgets.QLineEdit(default_conda_dir, self)
        self._progress = QtWidgets.QProgressBar(self)
        self._outputLine = QtWidgets.QLabel(self)
        self._output = QtWidgets.QPlainTextEdit(self)
        self._output.setReadOnly(True)
        self._button = QtWidgets.QPushButton('Install', self)
        
        self._outputLine.setSizePolicy(QtWidgets.QSizePolicy.Ignored, QtWidgets.QSizePolicy.Fixed)
        
        vbox = QtWidgets.QVBoxLayout(self)
        self.setLayout(vbox)
        vbox.addWidget(self._label, 0)
        vbox.addWidget(self._path, 0)
        vbox.addWidget(self._scipystack, 0)
        vbox.addWidget(self._progress, 0)
        vbox.addWidget(self._outputLine, 0)
        vbox.addWidget(self._output, 1)
        vbox.addWidget(self._button, 0)
        
        self._button.clicked.connect(self.go)
        
        self.addOutput(translate('bootstrapconda', 'Waiting to start installation.\n'))
        self._progress.setVisible(False)
        
        self.lineFromStdOut.connect(self.setStatus)
    
    def setStatus(self, line):
        self._outputLine.setText(line)
    
    def addOutput(self, text):
        #self._output.setPlainText(self._output.toPlainText() + '\n' + text)
        cursor = self._output.textCursor()
        cursor.movePosition(cursor.End, cursor.MoveAnchor)
        cursor.insertText(text)
        cursor.movePosition(cursor.End, cursor.MoveAnchor)
        self._output.setTextCursor(cursor)
        self._output.ensureCursorVisible()
    
    def addStatus(self, line):
        self.addOutput('\n' + line)
        self.setStatus(line)
    
    def go(self):
        
        # Check if we can install
        try:
            self._conda_dir = self._path.text()
            if not os.path.isabs(self._conda_dir):
                raise ValueError('Given installation path must be absolute.')
            if os.path.exists(self._conda_dir):
                raise ValueError('The given installation path already exists.')
        except Exception as err:
            self.addOutput('\nCould not install:\n' + str(err))
            return
        
        ok = False
        
        try:
            
            # Disable user input, get ready for installation
            self._progress.setVisible(True)
            self._button.clicked.disconnect()
            self._button.setEnabled(False)
            self._scipystack.setEnabled(False)
            self._path.setEnabled(False)
            
            if not os.path.exists(self._conda_dir):
                self.addStatus('Downloading installer ... ')
                self._progress.setMaximum(100)
                self.download()
                self.addStatus('Done downloading installer.')
                self.make_done()
                
                self.addStatus('Installing (this can take a minute) ... ')
                self._progress.setMaximum(0)
                ret = self.install()
                self.addStatus(('Failed' if ret else 'Done') + ' installing.')
                self.make_done()
            
            self.post_install()
            
            if self._scipystack.isChecked():
                self.addStatus('Installing scientific packages ... ')
                self._progress.setMaximum(0)
                ret = self.install_scipy()
                self.addStatus('Done installing scientific packages')
                self.make_done()
            
            self.addStatus('Verifying ... ')
            self._progress.setMaximum(100)
            ret = self.verify()
            if ret:
                self.addOutput('Error\n' + ret)
                self.addStatus('Verification Failed!')
            else:
                self.addOutput('Done verifying')
                self.addStatus('Ready to go!')
                self.make_done()
                ok = True
        
        except Exception as err:
            self.addStatus('Installation failed ...')
            self.addOutput('\n\nException!\n' + str(err))
        
        if not ok:
            self.addOutput('\n\nWe recommend installing miniconda or anaconda, ')
            self.addOutput('and making Pyzo aware if it via the shell configuration.')
        else:
            self.addOutput('\n\nYou can install additional packages by running "conda install" in the shell.')
        
        # Wrap up, allow user to exit
        self._progress.hide()
        self._button.setEnabled(True)
        self._button.setText('Close')
        self._button.clicked.connect(self.close)
    
    def make_done(self):
        self._progress.setMaximum(100)
        self._progress.setValue(100)
        etime = time.time() + 0.2
        while time.time() < etime:
            time.sleep(0.01)
            QtWidgets.qApp.processEvents()
    
    def download(self):
        
        # Installer already downloaded?
        if os.path.isfile(miniconda_path):
            self.addOutput('Already downloaded.')
            return  # os.remove(miniconda_path)
        
        # Get url key
        key = ''
        if sys.platform.startswith('win'):
            key = 'win'
        elif sys.platform.startswith('darwin'):
            key = 'osx'
        elif sys.platform.startswith('linux'):
            key = 'linux'
        key += '64' if is_64bit() else '32'
        
        # Get url
        if key not in links:
            raise RuntimeError('Cannot download miniconda for this platform.')
        url = base_url + links[key]
        
        _fetch_file(url, miniconda_path, self._progress)
    
    def install(self):
        dest = self._conda_dir
        
        # Clear dir 
        assert not os.path.isdir(dest), 'Miniconda dir already exists'
        assert ' ' not in dest, 'miniconda dest path must not contain spaces'
        
        if sys.platform.startswith('win'):
            return self._run_process([miniconda_path, '/S', '/D=%s' % dest])
        else:
            os.chmod(miniconda_path, os.stat(miniconda_path).st_mode | stat.S_IEXEC)
            return self._run_process([miniconda_path, '-b', '-p', dest])
    
    def post_install(self):
        
        exe = py_exe(self._conda_dir)
        
        # Add Pyzo channel
        cmd = [exe, '-m', 'conda', 'config', '--system', '--add', 'channels', 'pyzo']
        subprocess.check_call(cmd, shell=sys.platform.startswith('win'))
        self.addStatus('Added Pyzo channel to conda env')
        
        # Add to pyzo shell config
        first = None
        if pyzo.config.shellConfigs2 and pyzo.config.shellConfigs2[0]['exe'] == exe:
            pass
        else:
            s = pyzo.ssdf.new()
            s.name = 'Py3-conda'
            s.exe = exe
            s.gui='PyQt4'
            pyzo.config.shellConfigs2.insert(0, s)
            pyzo.saveConfig()
            self.addStatus('Prepended new env to Pyzo shell configs.')
    
    def install_scipy(self):
        
        packages = ['numpy', 'scipy', 'pandas', 'matplotlib', 'sympy',
                    #'scikit-image', 'scikit-learn', 
                    'pyopengl', # 'visvis', 'imageio',
                    'tornado', 'pyqt', #'ipython', 'jupyter',
                    #'requests', 'pygments','pytest', 
                    ]
        exe = py_exe(self._conda_dir)
        cmd = [exe, '-m', 'conda', 'install', '--yes'] + packages
        return self._run_process(cmd)
    
    def _run_process(self, cmd):
        """ Run command in a separate process, catch stdout, show lines
        in the output label. On fail, show all output in output text.
        """
        p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=sys.platform.startswith('win'))
        catcher = StreamCatcher(p.stdout, self.lineFromStdOut)
        
        while p.poll() is None:
            time.sleep(0.01)
            QtWidgets.qApp.processEvents()
        
        catcher.join()
        if p.poll():
            self.addOutput(catcher.output())
        return p.poll()
    
    def verify(self):
        
        self._progress.setValue(1)
        if not os.path.isdir(self._conda_dir):
            return 'Conda dir not created.'
        
        self._progress.setValue(11)
        exe = py_exe(self._conda_dir)
        if not os.path.isfile(exe):
           return 'Conda dir does not have Python exe' 
        
        self._progress.setValue(21)
        try:
            ver = subprocess.check_output([exe, '-c', 'import sys; print(sys.version)'])
        except Exception as err:
            return 'Error getting Python version: ' + str(err)
        
        self._progress.setValue(31)
        if ver.decode() < '3.4':
            return 'Expected Python version 3.4 or higher'
        
        self._progress.setValue(41)
        try:
            ver = subprocess.check_output([exe, '-c', 'import conda; print(conda.__version__)'])
        except Exception as err:
            return 'Error calling Python exe: ' + str(err)
        
        self._progress.setValue(51)
        if ver.decode() < '3.16':
            return 'Expected Conda version 3.16 or higher'
        
        # Smooth toward 100%
        for i in range(self._progress.value(), 100, 5):
            time.sleep(0.05)
            self._progress.setValue(i)
            QtWidgets.qApp.processEvents()
Exemple #8
0
class WebView(QtWidgets.QTextBrowser):
    """ Inherit the webview class to implement zooming using
    the mouse wheel. 
    """

    loadStarted = QtCore.Signal()
    loadFinished = QtCore.Signal(bool)

    def __init__(self, parent):
        QtWidgets.QTextBrowser.__init__(self, parent)

        # Current url
        self._url = ''
        self._history = []
        self._history2 = []

        # Connect
        self.anchorClicked.connect(self.load)

    def wheelEvent(self, event):
        # Zooming does not work for this widget
        if QtCore.Qt.ControlModifier & QtWidgets.qApp.keyboardModifiers():
            self.parent().wheelEvent(event)
        else:
            QtWidgets.QTextBrowser.wheelEvent(self, event)

    def url(self):
        return self._url

    def _getUrlParts(self):
        r = urllib.parse.urlparse(self._url)
        base = r.scheme + '://' + r.netloc
        return base, r.path, r.fragment


#
#     def loadCss(self, urls=[]):
#         urls.append('http://docs.python.org/_static/default.css')
#         urls.append('http://docs.python.org/_static/pygments.css')
#         text = ''
#         for url in urls:
#             tmp = urllib.request.urlopen(url).read().decode('utf-8')
#             text += '\n' + tmp
#         self.document().setDefaultStyleSheet(text)

    def back(self):

        # Get url and update forward history
        url = self._history.pop()
        self._history2.append(self._url)

        # Go there
        url = self._load(url)

    def forward(self):

        if not self._history2:
            return

        # Get url and update forward history
        url = self._history2.pop()
        self._history.append(self._url)

        # Go there
        url = self._load(url)

    def load(self, url):

        # Clear forward history
        self._history2 = []

        # Store current url in history
        while self._url in self._history:
            self._history.remove(self._url)
        self._history.append(self._url)

        # Load
        url = self._load(url)

    def _load(self, url):
        """ _load(url)
        Convert url and load page, returns new url.
        """
        # Make url a string
        if isinstance(url, QtCore.QUrl):
            url = str(url.toString())

        # Compose relative url to absolute
        if url.startswith('#'):
            base, path, frag = self._getUrlParts()
            url = base + path + url
        elif not '//' in url:
            base, path, frag = self._getUrlParts()
            url = base + '/' + url.lstrip('/')

        # Try loading
        self.loadStarted.emit()
        self._url = url
        try:
            #print('URL:', url)
            text = urllib.request.urlopen(url).read().decode('utf-8')
            self.setHtml(text)
            self.loadFinished.emit(True)
        except Exception as err:
            self.setHtml(str(err))
            self.loadFinished.emit(False)

        # Set
        return url
Exemple #9
0
class Installer(QtWidgets.QDialog):

    lineFromStdOut = QtCore.Signal(str)

    def __init__(self, parent=None):
        QtWidgets.QDialog.__init__(self, parent)
        self.setWindowTitle("Install miniconda")
        self.setModal(True)
        self.resize(500, 500)

        text = translate(
            "bootstrapconda",
            "This will download and install miniconda on your computer.",
        )

        self._label = QtWidgets.QLabel(text, self)

        self._scipystack = QtWidgets.QCheckBox(
            translate("bootstrapconda", "Also install scientific packages"), self
        )
        self._scipystack.setChecked(True)
        self._path = QtWidgets.QLineEdit(default_conda_dir, self)
        self._progress = QtWidgets.QProgressBar(self)
        self._outputLine = QtWidgets.QLabel(self)
        self._output = QtWidgets.QPlainTextEdit(self)
        self._output.setReadOnly(True)
        self._button = QtWidgets.QPushButton("Install", self)

        self._outputLine.setSizePolicy(
            QtWidgets.QSizePolicy.Ignored, QtWidgets.QSizePolicy.Fixed
        )

        vbox = QtWidgets.QVBoxLayout(self)
        self.setLayout(vbox)
        vbox.addWidget(self._label, 0)
        vbox.addWidget(self._path, 0)
        vbox.addWidget(self._scipystack, 0)
        vbox.addWidget(self._progress, 0)
        vbox.addWidget(self._outputLine, 0)
        vbox.addWidget(self._output, 1)
        vbox.addWidget(self._button, 0)

        self._button.clicked.connect(self.go)

        self.addOutput(translate("bootstrapconda", "Waiting to start installation.\n"))
        self._progress.setVisible(False)

        self.lineFromStdOut.connect(self.setStatus)

    def setStatus(self, line):
        self._outputLine.setText(line)

    def addOutput(self, text):
        # self._output.setPlainText(self._output.toPlainText() + '\n' + text)
        cursor = self._output.textCursor()
        cursor.movePosition(cursor.End, cursor.MoveAnchor)
        cursor.insertText(text)
        cursor.movePosition(cursor.End, cursor.MoveAnchor)
        self._output.setTextCursor(cursor)
        self._output.ensureCursorVisible()

    def addStatus(self, line):
        self.addOutput("\n" + line)
        self.setStatus(line)

    def go(self):

        # Check if we can install
        try:
            self._conda_dir = self._path.text()
            if not os.path.isabs(self._conda_dir):
                raise ValueError("Given installation path must be absolute.")
            if os.path.exists(self._conda_dir):
                raise ValueError("The given installation path already exists.")
        except Exception as err:
            self.addOutput("\nCould not install:\n" + str(err))
            return

        ok = False

        try:

            # Disable user input, get ready for installation
            self._progress.setVisible(True)
            self._button.clicked.disconnect()
            self._button.setEnabled(False)
            self._scipystack.setEnabled(False)
            self._path.setEnabled(False)

            if not os.path.exists(self._conda_dir):
                self.addStatus("Downloading installer ... ")
                self._progress.setMaximum(100)
                self.download()
                self.addStatus("Done downloading installer.")
                self.make_done()

                self.addStatus("Installing (this can take a minute) ... ")
                self._progress.setMaximum(0)
                ret = self.install()
                self.addStatus(("Failed" if ret else "Done") + " installing.")
                self.make_done()

            self.post_install()

            if self._scipystack.isChecked():
                self.addStatus("Installing scientific packages ... ")
                self._progress.setMaximum(0)
                ret = self.install_scipy()
                self.addStatus("Done installing scientific packages")
                self.make_done()

            self.addStatus("Verifying ... ")
            self._progress.setMaximum(100)
            ret = self.verify()
            if ret:
                self.addOutput("Error\n" + ret)
                self.addStatus("Verification Failed!")
            else:
                self.addOutput("Done verifying")
                self.addStatus("Ready to go!")
                self.make_done()
                ok = True

        except Exception as err:
            self.addStatus("Installation failed ...")
            self.addOutput("\n\nException!\n" + str(err))

        if not ok:
            self.addOutput("\n\nWe recommend installing miniconda or anaconda, ")
            self.addOutput("and making Pyzo aware if it via the shell configuration.")
        else:
            self.addOutput(
                '\n\nYou can install additional packages by running "conda install" in the shell.'
            )

        # Wrap up, allow user to exit
        self._progress.hide()
        self._button.setEnabled(True)
        self._button.setText("Close")
        self._button.clicked.connect(self.close)

    def make_done(self):
        self._progress.setMaximum(100)
        self._progress.setValue(100)
        etime = time.time() + 0.2
        while time.time() < etime:
            time.sleep(0.01)
            QtWidgets.qApp.processEvents()

    def download(self):

        # Installer already downloaded?
        if os.path.isfile(miniconda_path):
            self.addOutput("Already downloaded.")
            return  # os.remove(miniconda_path)

        # Get url key
        key = ""
        if sys.platform.startswith("win"):
            key = "win"
        elif sys.platform.startswith("darwin"):
            key = "osx"
        elif sys.platform.startswith("linux"):
            key = "linux"
        key += "64" if is_64bit() else "32"

        # Get url
        if key not in links:
            raise RuntimeError("Cannot download miniconda for this platform.")
        url = base_url + links[key]

        _fetch_file(url, miniconda_path, self._progress)

    def install(self):
        dest = self._conda_dir

        # Clear dir
        assert not os.path.isdir(dest), "Miniconda dir already exists"
        assert " " not in dest, "miniconda dest path must not contain spaces"

        if sys.platform.startswith("win"):
            return self._run_process([miniconda_path, "/S", "/D=%s" % dest])
        else:
            os.chmod(miniconda_path, os.stat(miniconda_path).st_mode | stat.S_IEXEC)
            return self._run_process([miniconda_path, "-b", "-p", dest])

    def post_install(self):

        exe = py_exe(self._conda_dir)

        # Add Pyzo channel
        cmd = [exe, "-m", "conda", "config", "--system", "--add", "channels", "pyzo"]
        subprocess.check_call(cmd, shell=sys.platform.startswith("win"))
        self.addStatus("Added Pyzo channel to conda env")

        # Add to pyzo shell config
        if pyzo.config.shellConfigs2 and pyzo.config.shellConfigs2[0]["exe"] == exe:
            pass
        else:
            s = pyzo.ssdf.new()
            s.name = "Py3-conda"
            s.exe = exe
            s.gui = "PyQt4"
            pyzo.config.shellConfigs2.insert(0, s)
            pyzo.saveConfig()
            self.addStatus("Prepended new env to Pyzo shell configs.")

    def install_scipy(self):

        packages = [
            "numpy",
            "scipy",
            "pandas",
            "matplotlib",
            "sympy",
            #'scikit-image', 'scikit-learn',
            "pyopengl",  # 'visvis', 'imageio',
            "tornado",
            "pyqt",  #'ipython', 'jupyter',
            #'requests', 'pygments','pytest',
        ]
        exe = py_exe(self._conda_dir)
        cmd = [exe, "-m", "conda", "install", "--yes"] + packages
        return self._run_process(cmd)

    def _run_process(self, cmd):
        """Run command in a separate process, catch stdout, show lines
        in the output label. On fail, show all output in output text.
        """
        p = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            shell=sys.platform.startswith("win"),
        )
        catcher = StreamCatcher(p.stdout, self.lineFromStdOut)

        while p.poll() is None:
            time.sleep(0.01)
            QtWidgets.qApp.processEvents()

        catcher.join()
        if p.poll():
            self.addOutput(catcher.output())
        return p.poll()

    def verify(self):

        self._progress.setValue(1)
        if not os.path.isdir(self._conda_dir):
            return "Conda dir not created."

        self._progress.setValue(11)
        exe = py_exe(self._conda_dir)
        if not os.path.isfile(exe):
            return "Conda dir does not have Python exe"

        self._progress.setValue(21)
        try:
            ver = subprocess.check_output([exe, "-c", "import sys; print(sys.version)"])
        except Exception as err:
            return "Error getting Python version: " + str(err)

        self._progress.setValue(31)
        if ver.decode() < "3.4":
            return "Expected Python version 3.4 or higher"

        self._progress.setValue(41)
        try:
            ver = subprocess.check_output(
                [exe, "-c", "import conda; print(conda.__version__)"]
            )
        except Exception as err:
            return "Error calling Python exe: " + str(err)

        self._progress.setValue(51)
        if ver.decode() < "3.16":
            return "Expected Conda version 3.16 or higher"

        # Smooth toward 100%
        for i in range(self._progress.value(), 100, 5):
            time.sleep(0.05)
            self._progress.setValue(i)
            QtWidgets.qApp.processEvents()
Exemple #10
0
class ThemeEditorWidget(QtWidgets.QWidget):
    """ The ThemeEditorWidgets allows to edits themes,
        it has one StyleEdit widget per StyleElements ("Editor.Text", 
        "Syntax.string"). It emits a signal on each style changes
        
        It also manages basic theme I/O :
            - adding new theme
            - renaming theme
            
    """

    styleChanged = QtCore.Signal(dict)
    done = QtCore.Signal(int)

    def __init__(self, themes, *args, editor=None, **kwargs):
        super().__init__(*args, **kwargs)

        # dict of themes, a deep copy of pyzo.themes
        self.themes = themes
        # We store the key name separate so we can easier track renames
        self.cur_theme_key = ""
        # The current theme being changed
        self.cur_theme = None

        # If an editor is given, connect to it
        self.editor = editor
        if self.editor is not None:
            self.editor.tokenClicked.connect(self.focusOnStyle)
            self.styleChanged.connect(self.editor.setStyle)

        # Display editables style formats in a scroll area
        self.scrollArea = scrollArea = QtWidgets.QScrollArea()
        self.scrollArea.setWidgetResizable(True)

        formLayout = QtWidgets.QFormLayout()
        self.styleEdits = {}

        # Add one pair of label and StyleEdit per style element description
        # to the formLayout and connect the StyleEdit signals to the updatedStyle method
        for styleDesc in pyzo.codeeditor.CodeEditor.getStyleElementDescriptions(
        ):
            label = QtWidgets.QLabel(text=styleDesc.name,
                                     toolTip=styleDesc.description)
            label.setWordWrap(True)
            styleEdit = StyleEdit(styleDesc, toolTip=styleDesc.description)
            styleEdit.styleChanged.connect(self.updatedStyle)
            self.styleEdits[styleDesc.key] = styleEdit
            formLayout.addRow(label, styleEdit)

        wrapper = QtWidgets.QWidget()
        wrapper.setLayout(formLayout)
        wrapper.setMinimumWidth(650)
        scrollArea.setWidget(wrapper)

        # Basic theme I/O

        curThemeLbl = QtWidgets.QLabel(text="Themes :")

        self.curThemeCmb = curThemeCmb = QtWidgets.QComboBox()
        current_index = -1
        for i, themeName in enumerate(self.themes.keys()):
            # We store the themeName in data in case the user renames one
            curThemeCmb.addItem(themeName, userData=themeName)
            if themeName == pyzo.config.settings.theme.lower():
                current_index = i
        curThemeCmb.addItem("New...")

        loadLayout = QtWidgets.QHBoxLayout()
        loadLayout.addWidget(curThemeLbl)
        loadLayout.addWidget(curThemeCmb)

        self.saveBtn = saveBtn = QtWidgets.QPushButton(text="Save")
        saveBtn.clicked.connect(self.saveTheme)
        exitBtn = QtWidgets.QPushButton(text="Apply theme")
        exitBtn.clicked.connect(self.ok)

        exitLayout = QtWidgets.QHBoxLayout()
        exitLayout.addWidget(exitBtn)
        exitLayout.addWidget(saveBtn)

        # Packing it up
        mainLayout = QtWidgets.QVBoxLayout()
        mainLayout.addLayout(loadLayout)
        mainLayout.addWidget(scrollArea)
        mainLayout.addLayout(exitLayout)
        self.setLayout(mainLayout)

        curThemeCmb.currentIndexChanged.connect(self.indexChanged)
        curThemeCmb.currentTextChanged.connect(self.setTheme)

        # Init
        if current_index >= 0:
            curThemeCmb.setCurrentIndex(current_index)
            self.setTheme(pyzo.config.settings.theme)

    def createTheme(self):
        """ Create a new theme based on the current
        theme selected. """

        index = self.curThemeCmb.currentIndex()
        if index != self.curThemeCmb.count() - 1:
            return self.curThemeCmb.setCurrentIndex(self.curThemeCmb.count() -
                                                    1)

        # Select a new name
        t = "new_theme_x"
        i = 1
        themeName = t.replace("x", str(i))
        while themeName in self.themes:
            i += 1
            themeName = t.replace("x", str(i))

        # Create new theme
        new_theme = {"name": themeName, "data": {}, "builtin": False}
        if self.cur_theme:
            new_theme["data"] = self.cur_theme["data"].copy()
        self.cur_theme_key = themeName
        self.cur_theme = new_theme
        self.themes[themeName] = new_theme

        self.curThemeCmb.setItemText(index, themeName)
        self.curThemeCmb.setItemData(index, themeName)

        self.curThemeCmb.setEditable(True)
        self.curThemeCmb.lineEdit().setCursorPosition(0)
        self.curThemeCmb.lineEdit().selectAll()

        self.saveBtn.setEnabled(True)

        self.curThemeCmb.addItem("New...", )

    def setTheme(self, name):
        """ Set the theme by its name. The combobox becomes editable only 
            if the theme is not builtin. This method is connected to the signal
            self.curThemeCmb.currentTextChanged ; so it also filters 
            parasites events """

        name = name.lower()

        if name != self.curThemeCmb.currentText():
            # An item was added to the comboBox
            # But it's not a user action so we quit
            print(" -> Cancelled because this was not a user action")
            return

        if self.cur_theme_key == self.curThemeCmb.currentData():
            # The user renamed an existing theme
            self.cur_theme["name"] = name
            return

        if name not in self.themes:
            return

        # Sets the curent theme key
        self.cur_theme_key = name
        self.cur_theme = self.themes[name]

        if self.cur_theme["builtin"]:
            self.saveBtn.setEnabled(False)
            self.saveBtn.setText("Cannot save builtin style")
        else:
            self.saveBtn.setEnabled(True)
            self.saveBtn.setText("Save")
        self.curThemeCmb.setEditable(not self.cur_theme["builtin"])

        for key, le in self.styleEdits.items():
            le.setStyle(self.cur_theme["data"][key])

    def saveTheme(self):
        """ Saves the current theme to the disk, in appDataDir/themes """

        if self.cur_theme["builtin"]:
            return
        themeName = self.curThemeCmb.currentText().strip()
        if not themeName:
            return

        # Get user theme dir and make sure it exists
        dir = os.path.join(pyzo.appDataDir, "themes")
        if not os.path.isdir(dir):
            os.mkdir(dir)

        # Try to delete the old file if it exists (useful if it was renamed)
        try:
            os.remove(os.path.join(dir, self.cur_theme_key + ".theme"))
        except Exception:
            pass

        # This is the needed because of the SSDF format:
        # it doesn't accept dots, so we put underscore instead
        data = {
            x.replace(".", "_"): y
            for x, y in self.cur_theme["data"].items()
        }

        fname = os.path.join(dir, themeName + ".theme")
        ssdf.save(fname, {"name": themeName, "data": data})
        print("Saved theme '%s' to '%s'" % (themeName, fname))

    def ok(self):
        """ On user click saves the cur_theme if modified
            and restart pyzo if the theme changed"""
        prev = pyzo.config.settings.theme
        new = self.cur_theme["name"]

        self.saveTheme()

        if prev != new:
            pyzo.config.settings.theme = new
            #This may be better
            pyzo.main.restart()
        else:
            self.done.emit(1)

    def indexChanged(self, index):
        # User selected the "new..." button
        if index == self.curThemeCmb.count() - 1:
            self.createTheme()

    def focusOnStyle(self, key):
        self.styleEdits[key].setFocus(True)
        self.scrollArea.ensureWidgetVisible(self.styleEdits[key])

    def updatedStyle(self, style, text):
        fmt = StyleFormat(self.cur_theme["data"][style])
        fmt.update(text)
        self.cur_theme["data"][style] = str(fmt)
        self.styleChanged.emit({style: text})
Exemple #11
0
class StyleEdit(QtWidgets.QWidget):
    """ The StyleLineEdit is a line that allows the edition
        of one style (i.e. "Editor.Text" or  "Syntax.identifier")
        with a given StyleElementDescription it find the editable 
        parts and display the adaptated widgets for edition
        (checkbok for bold and italic, combo box for linestyles...).
    """

    styleChanged = QtCore.Signal(str, str)

    def __init__(self, defaultStyle, *args, **kwargs):
        super().__init__(*args, **kwargs)

        #The styleKey is sent with the styleChanged signal for easy identification
        self.styleKey = defaultStyle.key

        self.layout = layout = QtWidgets.QHBoxLayout()
        # The setters are used when setting the style
        self.setters = {}

        #TODO: the use of StyleFormat._parts should be avoided
        # We use the StyleFormat._parts keys, to find the elements
        # Useful to edits, because the property may return a value
        # Even if they were not defined in the defaultFormat
        fmtParts = defaultStyle.defaultFormat._parts

        # Add the widgets corresponding to the fields
        if "fore" in fmtParts:
            self.__add_clrLineEdit("fore", "Foreground")
        if "back" in fmtParts:
            self.__add_clrLineEdit("back", "Background")
        if "bold" in fmtParts:
            self.__add_checkBox("bold", "Bold")
        if "italic" in fmtParts:
            self.__add_checkBox("italic", "Italic")
        if "underline" in fmtParts:
            self.__add_comboBox("underline", "Underline", "No", "Dotted",
                                "Wave", "Full", "Yes")
        if "linestyle" in fmtParts:
            self.__add_comboBox("linestyle", "Linestyle", "Dashed", "Dotted",
                                "Full")

        self.setLayout(layout)

        self.setSizePolicy(QtWidgets.QSizePolicy.Minimum,
                           QtWidgets.QSizePolicy.Minimum)

    def __add_clrLineEdit(self, key, name):
        """this is a helper method to create a ColorLineEdit
            it adds the created widget (as a TitledWidget) to the layout and
            register a setter and listen to changes 
        """
        clrEdit = ColorLineEdit(name)
        clrEdit.textChanged.connect(
            lambda txt, key=key: self.__update(key, txt))
        self.setters[key] = clrEdit.setText
        self.layout.addWidget(TitledWidget(name, clrEdit), 0)

    def __add_checkBox(self, key, name):
        """this is a helper method to create a QCheckBox
            it adds the created widget (as a TitledWidget) to the layout and
            register a setter and listen to changes
        """

        checkBox = QtWidgets.QCheckBox()

        self.setters[key] = (
            lambda val, check=checkBox: check.setCheckState(val == "yes"))

        checkBox.stateChanged.connect(lambda state, key=key: self.__update(
            key, "yes" if state else "no"))

        self.layout.addWidget(TitledWidget(name, checkBox))

    def __add_comboBox(self, key, name, *items):
        """this is a helper method to create a comboBox
            it adds the created widget (as a TitledWidget) to the layout and
            register a setter and listen to changes
        """

        combo = QtWidgets.QComboBox()
        combo.addItems(items)
        combo.currentTextChanged.connect(
            lambda txt, key=key: self.__update(key, txt))

        # Note: those setters may become problematic if
        # someone use the synonyms (defined in codeeditor/style.py)
        # i.e. a stylement is of form "linestyle:dashline"
        # instead of the "linestyle:dashed"
        self.setters[key] = lambda txt, cmb=combo: cmb.setCurrentText(
            txt.capitalize())
        self.layout.addWidget(TitledWidget(name, combo))

    def __update(self, key, value):
        """ this function is called everytime one of the children
        widget data has been modified by the user """
        self.styleChanged.emit(self.styleKey, key + ":" + value)

    def setStyle(self, text):
        """ updates every children to match the StyleFormat(text) fields"""
        style = StyleFormat(text)
        for key, setter in self.setters.items():
            setter(style[key])

    def setFocus(self, val):
        self.layout.itemAt(0).widget().setFocus(True)
Exemple #12
0
class ShellStackWidget(QtGui.QWidget):
    """ The shell stack widget provides a stack of shells.
    
    It wrapps a QStackedWidget that contains the shell objects. This 
    stack is used as a reference to synchronize the shell selection with.
    We keep track of what is the current selected shell and apply updates
    if necessary. Therefore, changing the current shell in the stack
    should be enough to invoke a full update.
    
    """

    # When the current shell changes.
    currentShellChanged = QtCore.Signal()

    # When the current shells state (or debug state) changes,
    # or when a new prompt is received.
    # Also fired when the current shell changes.
    currentShellStateChanged = QtCore.Signal()

    def __init__(self, parent):
        QtGui.QWidget.__init__(self, parent)

        # create toolbar
        self._toolbar = QtGui.QToolBar(self)
        self._toolbar.setMaximumHeight(25)
        self._toolbar.setIconSize(QtCore.QSize(16, 16))

        # create stack
        self._stack = QtGui.QStackedWidget(self)

        # Populate toolbar
        self._shellButton = ShellControl(self._toolbar, self._stack)
        self._debugmode = 0
        self._dbs = DebugStack(self._toolbar)
        #
        self._toolbar.addWidget(self._shellButton)
        self._toolbar.addSeparator()
        # self._toolbar.addWidget(self._dbc) -> delayed, see addContextMenu()

        self._condahelp = CondaHelper(self)

        # widget layout
        layout = QtGui.QVBoxLayout()
        layout.setSpacing(0)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.addWidget(self._toolbar)
        layout.addWidget(self._stack, 0)
        layout.addWidget(self._condahelp, 0)
        self.setLayout(layout)

        # make callbacks
        self._stack.currentChanged.connect(self.onCurrentChanged)

        # Make shared history (shared among shells)
        if PythonHistory is None:
            self.sharedHistory = None
        else:
            self.sharedHistory = PythonHistory('shellhistory.py')

        self.showCondaHelper()

    def __iter__(self):
        i = 0
        while i < self._stack.count():
            w = self._stack.widget(i)
            i += 1
            yield w

    def showCondaHelper(self, show=True):
        self._condahelp.setVisible(show)
        self._toolbar.setVisible(not show)
        self._stack.setVisible(not show)
        if show:
            self._condahelp.detect()

    def addShell(self, shellInfo=None):
        """ addShell()
        Add a shell to the widget. """

        # Create shell and add to stack
        shell = PythonShell(self, shellInfo, self.sharedHistory)
        index = self._stack.addWidget(shell)
        # Bind to signals
        shell.stateChanged.connect(self.onShellStateChange)
        shell.debugStateChanged.connect(self.onShellDebugStateChange)
        # Select it and focus on it (invokes onCurrentChanged)
        self._stack.setCurrentWidget(shell)
        shell.setFocus()
        return shell

    def removeShell(self, shell):
        """ removeShell()
        Remove an existing shell from the widget
        """
        self._stack.removeWidget(shell)

    def onCurrentChanged(self, index):
        """ When another shell is selected, update some things. 
        """

        # Get current
        shell = self.getCurrentShell()
        # Call functions
        self.onShellStateChange(shell)
        self.onShellDebugStateChange(shell)
        # Emit Signal
        self.currentShellChanged.emit()

    def onShellStateChange(self, shell):
        """ Called when the shell state changes, and is called
        by onCurrentChanged. Sets the mainwindow's icon if busy.
        """

        # Keep shell button and its menu up-to-date
        self._shellButton.updateShellMenu(shell)

        if shell is self.getCurrentShell():  # can be None
            # Update application icon
            if shell and shell._state in ['Busy']:
                pyzo.main.setWindowIcon(pyzo.iconRunning)
            else:
                pyzo.main.setWindowIcon(pyzo.icon)
            # Send signal
            self.currentShellStateChanged.emit()

    def onShellDebugStateChange(self, shell):
        """ Called when the shell debug state changes, and is called
        by onCurrentChanged. Sets the debug button.
        """

        if shell is self.getCurrentShell():

            # Update debug info
            if shell and shell._debugState:
                info = shell._debugState
                self._debugmode = info['debugmode']
                for action in self._debugActions:
                    action.setEnabled(self._debugmode == 2)
                self._debugActions[-1].setEnabled(self._debugmode > 0)  # Stop
                self._dbs.setTrace(shell._debugState)
            else:
                for action in self._debugActions:
                    action.setEnabled(False)
                self._debugmode = 0
                self._dbs.setTrace(None)
            # Send signal
            self.currentShellStateChanged.emit()

    def getCurrentShell(self):
        """ getCurrentShell()
        Get the currently active shell.
        """

        w = None
        if self._stack.count():
            w = self._stack.currentWidget()
        if not w:
            return None
        else:
            return w

    def getShells(self):
        """ Get all shell in stack as list """

        shells = []
        for i in range(self._stack.count()):
            shell = self.getShellAt(i)
            if shell is not None:
                shells.append(shell)

        return shells

    def getShellAt(self, i):
        return
        """ Get shell at current tab index """

        return self._stack.widget(i)

    def addContextMenu(self):
        # A bit awkward... but the ShellMenu needs the ShellStack, so it
        # can only be initialized *after* the shellstack is created ...

        # Give shell tool button a menu
        self._shellButton.setMenu(ShellButtonMenu(self, 'Shell button menu'))
        self._shellButton.menu().aboutToShow.connect(
            self._shellButton._elapsedTimesTimer.start)

        # Also give it a context menu
        self._shellButton.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self._shellButton.customContextMenuRequested.connect(
            self.contextMenuTriggered)

        # Add actions
        for action in pyzo.main.menuBar()._menumap['shell']._shellActions:
            action = self._toolbar.addAction(action)

        self._toolbar.addSeparator()

        # Add debug actions
        self._debugActions = []
        for action in pyzo.main.menuBar()._menumap['shell']._shellDebugActions:
            self._debugActions.append(action)
            action = self._toolbar.addAction(action)

        # Delayed-add debug control buttons
        self._toolbar.addWidget(self._dbs)

    def contextMenuTriggered(self, p):
        """ Called when context menu is clicked """

        # Get index of shell belonging to the tab
        shell = self.getCurrentShell()

        if shell:
            p = self._shellButton.mapToGlobal(
                self._shellButton.rect().bottomLeft())
            ShellTabContextMenu(shell=shell, parent=self).popup(p)

    def onShellAction(self, action):
        shell = self.getCurrentShell()
        if shell:
            getattr(shell, action)()
Exemple #13
0
class EditorTabs(QtGui.QWidget):
    """ The EditorTabs instance manages the open files and corresponding
    editors. It does the saving loading etc.
    """

    # Signal to indicate that a breakpoint has changed, emits dict
    breakPointsChanged = QtCore.Signal(object)

    # Signal to notify that a different file was selected
    currentChanged = QtCore.Signal()

    # Signal to notify that the parser has parsed the text (emit by parser)
    parserDone = QtCore.Signal()

    def __init__(self, parent):
        QtGui.QWidget.__init__(self, parent)

        # keep a booking of opened directories
        self._lastpath = ''

        # keep track of all breakpoints
        self._breakPoints = {}

        # create tab widget
        self._tabs = FileTabWidget(self)
        self._tabs.tabCloseRequested.connect(self.closeFile)
        self._tabs.currentChanged.connect(self.onCurrentChanged)

        # Double clicking a tab saves the file, clicking on the bar opens a new file
        self._tabs.tabBar().tabDoubleClicked.connect(self.saveFile)
        self._tabs.tabBar().barDoubleClicked.connect(self.newFile)

        # Create find/replace widget
        self._findReplace = FindReplaceWidget(self)

        # create box layout control and add widgets
        self._boxLayout = QtGui.QVBoxLayout(self)
        self._boxLayout.addWidget(self._tabs, 1)
        self._boxLayout.addWidget(self._findReplace, 0)
        # spacing of widgets
        self._boxLayout.setSpacing(0)
        # apply
        self.setLayout(self._boxLayout)

        #self.setAttribute(QtCore.Qt.WA_AlwaysShowToolTips,True)

        # accept drops
        self.setAcceptDrops(True)

        # restore state (call later so that the menu module can bind to the
        # currentChanged signal first, in order to set tab/indentation
        # checkmarks appropriately)
        # todo: Resetting the scrolling would work better if set after
        # the widgets are properly sized.
        pyzo.callLater(self.restoreEditorState)

    def addContextMenu(self):
        """ Adds a context menu to the tab bar """

        from pyzo.core.menu import EditorTabContextMenu
        self._menu = EditorTabContextMenu(self, "EditorTabMenu")
        self._tabs.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self._tabs.customContextMenuRequested.connect(
            self.contextMenuTriggered)

    def contextMenuTriggered(self, p):
        """ Called when context menu is clicked """

        # Get index of current tab
        index = self._tabs.tabBar().tabAt(p)
        self._menu.setIndex(index)

        # Show menu if item is available
        if index >= 0:
            p = self._tabs.tabBar().tabRect(index).bottomLeft()
            self._menu.popup(self._tabs.tabBar().mapToGlobal(p))

    def onCurrentChanged(self):
        self.currentChanged.emit()

    def getCurrentEditor(self):
        """ Get the currently active editor. """
        item = self._tabs.currentItem()
        if item:
            return item.editor
        else:
            return None

    def getMainEditor(self):
        """ Get the editor that represents the main file, or None if
        there is no main file. """
        item = self._tabs.mainItem()
        if item:
            return item.editor
        else:
            return None

    def __iter__(self):
        tmp = [item.editor for item in self._tabs.items()]
        return tmp.__iter__()

    def updateBreakPoints(self, editor=None):
        # Get list of editors to update keypoints for
        if editor is None:
            editors = self
            self._breakPoints = {}  # Full reset
        else:
            editors = [editor]

        # Update our keypoints dict
        for editor in editors:
            fname = editor._filename or editor._name
            if not fname:
                continue
            linenumbers = editor.breakPoints()
            if linenumbers:
                self._breakPoints[fname] = linenumbers
            else:
                self._breakPoints.pop(fname, None)

        # Emit signal so shells can update the kernel
        self.breakPointsChanged.emit(self._breakPoints)

    def setDebugLineIndicators(self, *filename_linenr):
        """ Set the debug line indicator. There is one indicator
        global to pyzo, corresponding to the last shell for which we
        received the indicator.
        """
        if len(filename_linenr) and filename_linenr[0] is None:
            filename_linenr = []

        # Normalize case
        filename_linenr = [(os.path.normcase(i[0]), int(i[1]))
                           for i in filename_linenr]

        for item in self._tabs.items():
            # Prepare
            editor = item._editor
            fname = editor._filename or editor._name
            fname = os.path.normcase(fname)
            # Reset
            editor.setDebugLineIndicator(None)
            # Set
            for filename, linenr in filename_linenr:
                if fname == filename:
                    active = (filename, linenr) == filename_linenr[-1]
                    editor.setDebugLineIndicator(linenr, active)

    ## Loading ad saving files

    def dragEnterEvent(self, event):
        if event.mimeData().hasUrls():
            event.acceptProposedAction()

    def dropEvent(self, event):
        """ Drop files in the list. """
        for qurl in event.mimeData().urls():
            path = str(qurl.toLocalFile())
            if os.path.isfile(path):
                self.loadFile(path)
            elif os.path.isdir(path):
                self.loadDir(path)
            else:
                pass

    def newFile(self):
        """ Create a new (unsaved) file. """

        # create editor
        editor = createEditor(self, None)
        editor.document().setModified(False)  # Start out as OK
        # add to list
        item = FileItem(editor)
        self._tabs.addItem(item)
        self._tabs.setCurrentItem(item)
        # set focus to new file
        editor.setFocus()

        return item

    def openFile(self):
        """ Create a dialog for the user to select a file. """

        # determine start dir
        # todo: better selection of dir, using project manager
        editor = self.getCurrentEditor()
        if editor and editor._filename:
            startdir = os.path.split(editor._filename)[0]
        else:
            startdir = self._lastpath
        if (not startdir) or (not os.path.isdir(startdir)):
            startdir = ''

        # show dialog
        msg = translate("editorTabs", "Select one or more files to open")
        filter = "Python (*.py *.pyw);;"
        filter += "Pyrex (*.pyi *.pyx *.pxd);;"
        filter += "C (*.c *.h *.cpp *.c++);;"
        #filter += "Py+Cy+C (*.py *.pyw *.pyi *.pyx *.pxd *.c *.h *.cpp);;"
        filter += "All (*)"
        if True:
            filenames = QtGui.QFileDialog.getOpenFileNames(
                self, msg, startdir, filter)
            if isinstance(filenames, tuple):  # PySide
                filenames = filenames[0]
        else:
            # Example how to preselect files, can be used when the users
            # opens a file in a project to select all files currently not
            # loaded.
            d = QtGui.QFileDialog(self, msg, startdir, filter)
            d.setFileMode(d.ExistingFiles)
            d.selectFile('"codeparser.py" "editorStack.py"')
            d.exec_()
            if d.result():
                filenames = d.selectedFiles()
            else:
                filenames = []

        # were some selected?
        if not filenames:
            return

        # load
        for filename in filenames:
            self.loadFile(filename)

    def openDir(self):
        """ Create a dialog for the user to select a directory. """

        # determine start dir
        editor = self.getCurrentEditor()
        if editor and editor._filename:
            startdir = os.path.split(editor._filename)[0]
        else:
            startdir = self._lastpath
        if not os.path.isdir(startdir):
            startdir = ''

        # show dialog
        msg = "Select a directory to open"
        dirname = QtGui.QFileDialog.getExistingDirectory(self, msg, startdir)

        # was a dir selected?
        if not dirname:
            return

        # load
        self.loadDir(dirname)

    def loadFile(self, filename, updateTabs=True):
        """ Load the specified file. 
        On success returns the item of the file, also if it was
        already open."""

        # Note that by giving the name of a tempfile, we can select that
        # temp file.

        # normalize path
        if filename[0] != '<':
            filename = normalizePath(filename)
        if not filename:
            return None

        # if the file is already open...
        for item in self._tabs.items():
            if item.id == filename:
                # id gets _filename or _name for temp files
                break
        else:
            item = None
        if item:
            self._tabs.setCurrentItem(item)
            print("File already open: '{}'".format(filename))
            return item

        # create editor
        try:
            editor = createEditor(self, filename)
        except Exception as err:
            # Notify in logger
            print("Error loading file: ", err)
            # Make sure the user knows
            m = QtGui.QMessageBox(self)
            m.setWindowTitle("Error loading file")
            m.setText(str(err))
            m.setIcon(m.Warning)
            m.exec_()
            return None

        # create list item
        item = FileItem(editor)
        self._tabs.addItem(item, updateTabs)
        if updateTabs:
            self._tabs.setCurrentItem(item)

        # store the path
        self._lastpath = os.path.dirname(item.filename)

        return item

    def loadDir(self, path):
        """ Create a project with the dir's name and add all files
        contained in the directory to it.
        extensions is a komma separated list of extenstions of files
        to accept...        
        """

        # if the path does not exist, stop
        path = os.path.abspath(path)
        if not os.path.isdir(path):
            print("ERROR loading dir: the specified directory does not exist!")
            return

        # get extensions
        extensions = pyzo.config.advanced.fileExtensionsToLoadFromDir
        extensions = extensions.replace(',', ' ').replace(';', ' ')
        extensions = [
            "." + a.lstrip(".").strip() for a in extensions.split(" ")
        ]

        # init item
        item = None

        # open all qualified files...
        self._tabs.setUpdatesEnabled(False)
        try:
            filelist = os.listdir(path)
            for filename in filelist:
                filename = os.path.join(path, filename)
                ext = os.path.splitext(filename)[1]
                if str(ext) in extensions:
                    item = self.loadFile(filename, False)
        finally:
            self._tabs.setUpdatesEnabled(True)
            self._tabs.updateItems()

        # return lastopened item
        return item

    def saveFileAs(self, editor=None):
        """ Create a dialog for the user to select a file. 
        returns: True if succesfull, False if fails
        """

        # get editor
        if editor is None:
            editor = self.getCurrentEditor()
        if editor is None:
            return False

        # get startdir
        if editor._filename:
            startdir = os.path.dirname(editor._filename)
        else:
            startdir = self._lastpath
            # Try the file browser or project manager to suggest a path
            fileBrowser = pyzo.toolManager.getTool('pyzofilebrowser')
            projectManager = pyzo.toolManager.getTool('pyzoprojectmanager')
            if fileBrowser:
                startdir = fileBrowser.getDefaultSavePath()
            if projectManager and not startdir:
                startdir = projectManager.getDefaultSavePath()

        if not os.path.isdir(startdir):
            startdir = ''

        # show dialog
        msg = translate("editorTabs", "Select the file to save to")
        filter = "Python (*.py *.pyw);;"
        filter += "Pyrex (*.pyi *.pyx *.pxd);;"
        filter += "C (*.c *.h *.cpp);;"
        #filter += "Py+Cy+C (*.py *.pyw *.pyi *.pyx *.pxd *.c *.h *.cpp);;"
        filter += "All (*.*)"
        filename = QtGui.QFileDialog.getSaveFileName(self, msg, startdir,
                                                     filter)
        if isinstance(filename, tuple):  # PySide
            filename = filename[0]

        # give python extension if it has no extension
        head, tail = os.path.split(filename)
        if tail and '.' not in tail:
            filename += '.py'

        # proceed or cancel
        if filename:
            return self.saveFile(editor, filename)
        else:
            return False  # Cancel was pressed

    def saveFile(self, editor=None, filename=None):
        """ Save the file. 
        returns: True if succesfull, False if fails
        """

        # get editor
        if editor is None:
            editor = self.getCurrentEditor()
        elif isinstance(editor, int):
            index = editor
            editor = None
            if index >= 0:
                item = self._tabs.items()[index]
                editor = item.editor
        if editor is None:
            return False

        # get filename
        if filename is None:
            filename = editor._filename
        if not filename:
            return self.saveFileAs(editor)

        # let the editor do the low level stuff...
        try:
            editor.save(filename)
        except Exception as err:
            # Notify in logger
            print("Error saving file:", err)
            # Make sure the user knows
            m = QtGui.QMessageBox(self)
            m.setWindowTitle("Error saving file")
            m.setText(str(err))
            m.setIcon(m.Warning)
            m.exec_()
            # Return now
            return False

        # get actual normalized filename
        filename = editor._filename

        # notify
        # TODO: message concerining line endings
        print("saved file: {} ({})".format(filename,
                                           editor.lineEndingsHumanReadable))
        self._tabs.updateItems()

        # todo: this is where we once detected whether the file being saved was a style file.

        # Notify done
        return True

    def saveAllFiles(self):
        """ Save all files"""
        for editor in self:
            self.saveFile(editor)

    ## Closing files / closing down

    def askToSaveFileIfDirty(self, editor):
        """ askToSaveFileIfDirty(editor)
        
        If the given file is not saved, pop up a dialog
        where the user can save the file
        . 
        Returns 1 if file need not be saved.
        Returns 2 if file was saved.
        Returns 3 if user discarded changes.
        Returns 0 if cancelled.
        
        """

        # should we ask to save the file?
        if editor.document().isModified():

            # Ask user what to do
            result = simpleDialog(editor, "Closing", "Save modified file?",
                                  ['Discard', 'Cancel', 'Save'], 'Save')
            result = result.lower()

            # Get result and act
            if result == 'save':
                return 2 if self.saveFile(editor) else 0
            elif result == 'discard':
                return 3
            else:  # cancel
                return 0

        return 1

    def closeFile(self, editor=None):
        """ Close the selected (or current) editor. 
        Returns same result as askToSaveFileIfDirty() """

        # get editor
        if editor is None:
            editor = self.getCurrentEditor()
            item = self._tabs.currentItem()
        elif isinstance(editor, int):
            index = editor
            editor, item = None, None
            if index >= 0:
                item = self._tabs.items()[index]
                editor = item.editor
        else:
            item = None
            for i in self._tabs.items():
                if i.editor is editor:
                    item = i
        if editor is None or item is None:
            return

        # Ask if dirty
        result = self.askToSaveFileIfDirty(editor)

        # Ask if closing pinned file
        if result and item.pinned:
            result = simpleDialog(
                editor, "Closing pinned",
                "Are you sure you want to close this pinned file?",
                ['Close', 'Cancel'], 'Cancel')
            result = result == 'Close'

        # ok, close...
        if result:
            if editor._name.startswith("<tmp"):
                # Temp file, try to find its index
                for i in range(len(self._tabs.items())):
                    if self._tabs.getItemAt(i).editor is editor:
                        self._tabs.removeTab(i)
                        break
            else:
                self._tabs.removeTab(editor)

        # Clear any breakpoints that it may have had
        self.updateBreakPoints()

        return result

    def closeAllFiles(self):
        """Close all files"""
        for editor in self:
            self.closeFile(editor)

    def saveEditorState(self):
        """ Save the editor's state configuration.
        """
        fr = self._findReplace
        pyzo.config.state.find_matchCase = fr._caseCheck.isChecked()
        pyzo.config.state.find_regExp = fr._regExp.isChecked()
        pyzo.config.state.find_wholeWord = fr._wholeWord.isChecked()
        pyzo.config.state.find_show = fr.isVisible()
        #
        pyzo.config.state.editorState2 = self._getCurrentOpenFilesAsSsdfList()

    def restoreEditorState(self):
        """ Restore the editor's state configuration.
        """

        # Restore opened editors
        if pyzo.config.state.editorState2:
            self._setCurrentOpenFilesAsSsdfList(pyzo.config.state.editorState2)
        else:
            self.newFile()

        # The find/replace state is set in the corresponding class during init

    def _getCurrentOpenFilesAsSsdfList(self):
        """ Get the state as it currently is as an ssdf list.
        The state entails all open files and their structure in the
        projects. The being collapsed of projects and their main files.
        The position of the cursor in the editors.
        """

        # Init
        state = []

        # Get items
        for item in self._tabs.items():

            # Get editor
            ed = item.editor
            if not ed._filename:
                continue

            # Init info
            info = []
            # Add filename, line number, and scroll distance
            info.append(ed._filename)
            info.append(int(ed.textCursor().position()))
            info.append(int(ed.verticalScrollBar().value()))
            # Add whether pinned or main file
            if item.pinned:
                info.append('pinned')
            if item.id == self._tabs._mainFile:
                info.append('main')

            # Add to state
            state.append(tuple(info))

        # Get history
        history = [item for item in self._tabs._itemHistory]
        history.reverse()  # Last one is current
        for item in history:
            if isinstance(item, FileItem):
                ed = item._editor
                if ed._filename:
                    state.append((ed._filename, 'hist'))

        # Done
        return state

    def _setCurrentOpenFilesAsSsdfList(self, state):
        """ Set the state of the editor in terms of opened files.
        The input should be a list object as returned by 
        ._getCurrentOpenFilesAsSsdfList().
        """

        # Init dict
        fileItems = {}

        # Process items
        for item in state:
            fname = item[0]
            if item[1] == 'hist':
                # select item (to make the history right)
                if fname in fileItems:
                    self._tabs.setCurrentItem(fileItems[fname])
            elif fname:
                # a file item, create editor-item and store
                itm = self.loadFile(fname)
                fileItems[fname] = itm
                # set position
                if itm:
                    try:
                        ed = itm.editor
                        cursor = ed.textCursor()
                        cursor.setPosition(int(item[1]))
                        ed.setTextCursor(cursor)
                        # set scrolling
                        ed.verticalScrollBar().setValue(int(item[2]))
                        #ed.centerCursor() #TODO: this does not work properly yet
                        # set main and/or pinned?
                        if 'main' in item:
                            self._tabs._mainFile = itm.id
                        if 'pinned' in item:
                            itm._pinned = True
                    except Exception as err:
                        print('Could not set position for %s' % fname, err)

    def closeAll(self):
        """ Close all files (well technically, we don't really close them,
        so that they are all stil there when the user presses cancel).
        Returns False if the user pressed cancel when asked for
        saving an unsaved file. 
        """

        # try closing all editors.
        for editor in self:
            result = self.askToSaveFileIfDirty(editor)
            if not result:
                return False

        # we're good to go closing
        return True