def __saArguments(self, argsStr):
     """
     Private method used to handle the "Arguments" command.
     
     @param argsStr space delimited list of command args(string)
     """
     e4App().getObject("DebugUI").setArgvHistory(argsStr)
 def deactivate(self):
     """
     Public method to deactivate this plugin.
     """
     self.disconnect(e4App().getObject("Project"), SIGNAL("showMenu"), 
                     self.__projectShowMenu)
     self.disconnect(e4App().getObject("ProjectBrowser").getProjectBrowser("sources"), 
                     SIGNAL("showMenu"), self.__projectBrowserShowMenu)
     self.disconnect(e4App().getObject("ViewManager"), SIGNAL("editorOpenedEd"), 
                     self.__editorOpened)
     self.disconnect(e4App().getObject("ViewManager"), SIGNAL("editorClosedEd"), 
                     self.__editorClosed)
     
     menu = e4App().getObject("Project").getMenu("Checks")
     if menu:
         menu.removeAction(self.__projectAct)
     
     if self.__projectBrowserMenu:
         if self.__projectBrowserAct:
             self.__projectBrowserMenu.removeAction(self.__projectBrowserAct)
     
     for editor in self.__editors:
         self.disconnect(editor, SIGNAL("showMenu"), self.__editorShowMenu)
         menu = editor.getMenu("Checks")
         if menu is not None:
             menu.removeAction(self.__editorAct)
     
     self.__initialize()
 def __saOpenFile(self, fname):
     """
     Private method used to handle the "Open File" command.
     
     @param fname filename to be opened (string)
     """
     e4App().getObject("ViewManager").openSourceFile(fname)
 def __saOpenProject(self, pfname):
     """
     Private method used to handle the "Open Project" command.
     
     @param pfname filename of the project to be opened (string)
     """
     e4App().getObject("Project").openProject(pfname)
예제 #5
0
    def activate(self):
        """
        Public method to activate this plugin.
        
        @return tuple of None and activation status (boolean)
        """
        menu = e4App().getObject("Project").getMenu("Apidoc")
        if menu:
            self.__projectAct = E4Action(
                self.trUtf8("Generate API file (eric4_api)"),
                self.trUtf8("Generate &API file (eric4_api)"),
                0,
                0,
                self,
                "doc_eric4_api",
            )
            self.__projectAct.setStatusTip(self.trUtf8("Generate an API file using eric4_api"))
            self.__projectAct.setWhatsThis(
                self.trUtf8("""<b>Generate API file</b>""" """<p>Generate an API file using eric4_api.</p>""")
            )
            self.connect(self.__projectAct, SIGNAL("triggered()"), self.__doEricapi)
            e4App().getObject("Project").addE4Actions([self.__projectAct])
            menu.addAction(self.__projectAct)

        self.connect(e4App().getObject("Project"), SIGNAL("showMenu"), self.__projectShowMenu)

        return None, True
 def activate(self):
     """
     Public method to activate this plugin.
     
     @return tuple of None and activation status (boolean)
     """
     menu = e4App().getObject("Project").getMenu("Apidoc")
     if menu:
         self.__projectAct = \
             E4Action(self.trUtf8('Generate documentation (eric4_doc)'),
                 self.trUtf8('Generate &documentation (eric4_doc)'), 0, 0,
                 self, 'doc_eric4_doc')
         self.__projectAct.setStatusTip(\
             self.trUtf8('Generate API documentation using eric4_doc'))
         self.__projectAct.setWhatsThis(self.trUtf8(
             """<b>Generate documentation</b>"""
             """<p>Generate API documentation using eric4_doc.</p>"""
         ))
         self.connect(self.__projectAct, SIGNAL('triggered()'), self.__doEricdoc)
         e4App().getObject("Project").addE4Actions([self.__projectAct])
         menu.addAction(self.__projectAct)
     
     self.connect(e4App().getObject("Project"), SIGNAL("showMenu"), 
                  self.__projectShowMenu)
     
     return None, True
예제 #7
0
 def __configure(self):
     """
     Private method to open the configuration dialog.
     """
     if self.__embeddedBrowser == 1:
         e4App().getObject("UserInterface").showPreferences("debuggerGeneralPage")
     elif self.__embeddedBrowser == 2:
         e4App().getObject("UserInterface").showPreferences("projectBrowserPage")
 def __init__(self, project):
     """
     Constructor
     
     @param project Reference to the project object to store the
             information into.
     """
     XMLHandlerBase.__init__(self)
     
     self.startDocumentSpecific = self.startDocumentSession
     
     self.elements.update({
         'Session' : (self.startSession, self.defaultEndElement),
         'MultiProject' : (self.defaultStartElement, self.endMultiProject),
         'Project' : (self.defaultStartElement, self.endProject),
         'Filename' : (self.startFilename, self.endFilename),
         'ActiveWindow' : (self.startFilename, self.endFilename),
         'Breakpoint' : (self.startBreakpoint, self.endBreakpoint),
         'BpFilename' : (self.defaultStartElement, self.endBFilename),
         'Linenumber' : (self.startLinenumber, self.defaultEndElement),
         'Condition' : (self.defaultStartElement, self.endCondition),
         'Enabled' : (self.startEnabled, self.defaultEndElement),
         'Temporary' : (self.startTemporary, self.defaultEndElement),
         'Count' : (self.startCount, self.defaultEndElement),
         'Watchexpression' : (self.startWatchexpression, self.endWatchexpression),
         'Special' : (self.defaultStartElement, self.endSpecial),
         'CommandLine' : (self.defaultStartElement, self.endCommandLine),
         'WorkingDirectory' : (self.defaultStartElement, self.endWorkingDirectory),
         'Environment' : (self.defaultStartElement, self.endEnvironment),
         'ReportExceptions' : (self.startReportExceptions, self.defaultEndElement),
         'Exceptions' : (self.startExceptions, self.endExceptions),
         'Exception' : (self.defaultStartElement, self.endException),
         'IgnoredExceptions' : (self.startIgnoredExceptions, self.endIgnoredExceptions),
         'IgnoredException' : (self.defaultStartElement, self.endIgnoredException),
         'AutoClearShell' : (self.startAutoClearShell, self.defaultEndElement),
         'TracePython' : (self.startTracePython, self.defaultEndElement),
         'AutoContinue' : (self.startAutoContinue, self.defaultEndElement),
         'Bookmark' : (self.startBookmark, self.endBookmark),
         'BmFilename' : (self.defaultStartElement, self.endBFilename),
         
         ####################################################################
         ## backward compatibility
         ####################################################################
         'Watchpoint' : (self.startWatchexpression, self.endWatchexpression),    # 4.0
         'CovexcPattern' : (self.defaultStartElement, self.defaultEndElement),   # 4.3
     })
 
     self.project = project
     self.isGlobal = project is None
     
     self.project = e4App().getObject("Project")
     self.multiProject = e4App().getObject("MultiProject")
     self.vm = e4App().getObject("ViewManager")
     self.dbg = e4App().getObject("DebugUI")
     self.dbs = e4App().getObject("DebugServer")
예제 #9
0
    def deactivate(self):
        """
        Public method to deactivate this plugin.
        """
        self.disconnect(e4App().getObject("Project"), SIGNAL("showMenu"), self.__projectShowMenu)

        menu = e4App().getObject("Project").getMenu("Apidoc")
        if menu:
            menu.removeAction(self.__projectAct)
            e4App().getObject("Project").removeE4Actions([self.__projectAct])
        self.__initialize()
 def __init__(self, file, projectName):
     """
     Constructor
     
     @param file open file (like) object for writing
     @param projectName name of the project (string)
     """
     XMLWriterBase.__init__(self, file)
     
     self.pudata = e4App().getObject("Project").pudata
     self.pdata = e4App().getObject("Project").pdata
     self.name = projectName
 def on_resultList_itemActivated(self, itm, col):
     """
     Private slot to handle the activation of an item. 
     
     @param itm reference to the activated item (QTreeWidgetItem)
     @param col column the item was activated in (integer)
     """
     if self.noResults:
         return
     
     fn = Utilities.normabspath(unicode(itm.text(0)))
     lineno = int(str(itm.text(1)))
     
     e4App().getObject("ViewManager").openSourceFile(fn, lineno)
 def __init__(self, file, projectName):
     """
     Constructor
     
     @param file open file (like) object for writing
     @param projectName name of the project (string) or None for the
         global session
     """
     XMLWriterBase.__init__(self, file)
     
     self.name = projectName
     self.project = e4App().getObject("Project")
     self.multiProject = e4App().getObject("MultiProject")
     self.vm = e4App().getObject("ViewManager")
     self.dbg = e4App().getObject("DebugUI")
     self.dbs = e4App().getObject("DebugServer")
 def __init__(self, parent = None, fromEric = True):
     """
     Constructor
     
     @param parent parent widget (QWidget)
     @param fromEric flag indicating a call from within eric4
     """
     QWidget.__init__(self,parent)
     self.setupUi(self)
     
     # initialize icons of the tool buttons
     self.charButton.setIcon(UI.PixmapCache.getIcon("characters.png"))
     self.anycharButton.setIcon(UI.PixmapCache.getIcon("anychar.png"))
     self.repeatButton.setIcon(UI.PixmapCache.getIcon("repeat.png"))
     self.nonGroupButton.setIcon(UI.PixmapCache.getIcon("nongroup.png"))
     self.groupButton.setIcon(UI.PixmapCache.getIcon("group.png"))
     self.altnButton.setIcon(UI.PixmapCache.getIcon("altn.png"))
     self.beglineButton.setIcon(UI.PixmapCache.getIcon("begline.png"))
     self.endlineButton.setIcon(UI.PixmapCache.getIcon("endline.png"))
     self.wordboundButton.setIcon(UI.PixmapCache.getIcon("wordboundary.png"))
     self.nonwordboundButton.setIcon(UI.PixmapCache.getIcon("nonwordboundary.png"))
     self.poslookaheadButton.setIcon(UI.PixmapCache.getIcon("poslookahead.png"))
     self.neglookaheadButton.setIcon(UI.PixmapCache.getIcon("neglookahead.png"))
     self.undoButton.setIcon(UI.PixmapCache.getIcon("editUndo.png"))
     self.redoButton.setIcon(UI.PixmapCache.getIcon("editRedo.png"))
     
     self.saveButton = \
         self.buttonBox.addButton(self.trUtf8("Save"), QDialogButtonBox.ActionRole)
     self.saveButton.setToolTip(self.trUtf8("Save the regular expression to a file"))
     self.loadButton = \
         self.buttonBox.addButton(self.trUtf8("Load"), QDialogButtonBox.ActionRole)
     self.loadButton.setToolTip(self.trUtf8("Load a regular expression from a file"))
     self.validateButton = \
         self.buttonBox.addButton(self.trUtf8("Validate"), QDialogButtonBox.ActionRole)
     self.validateButton.setToolTip(self.trUtf8("Validate the regular expression"))
     self.executeButton = \
         self.buttonBox.addButton(self.trUtf8("Execute"), QDialogButtonBox.ActionRole)
     self.executeButton.setToolTip(self.trUtf8("Execute the regular expression"))
     self.nextButton = \
         self.buttonBox.addButton(self.trUtf8("Next match"), 
                                  QDialogButtonBox.ActionRole)
     self.nextButton.setToolTip(\
         self.trUtf8("Show the next match of the regular expression"))
     self.nextButton.setEnabled(False)
     
     if fromEric:
         self.buttonBox.button(QDialogButtonBox.Close).hide()
         self.copyButton = None
         uitype = e4App().getObject("Project").getProjectType()
     else:
         self.copyButton = \
             self.buttonBox.addButton(self.trUtf8("Copy"), QDialogButtonBox.ActionRole)
         self.copyButton.setToolTip(\
             self.trUtf8("Copy the regular expression to the clipboard"))
         self.buttonBox.button(QDialogButtonBox.Ok).hide()
         self.buttonBox.button(QDialogButtonBox.Cancel).hide()
         self.variableLabel.hide()
         self.variableLineEdit.hide()
         self.variableLine.hide()
         self.regexpLineEdit.setFocus()
예제 #14
0
    def __doEricapi(self):
        """
        Private slot to perform the eric4_api api generation.
        """
        project = e4App().getObject("Project")
        parms = project.getData("DOCUMENTATIONPARMS", "ERIC4API")
        dlg = EricapiConfigDialog(project, parms)
        if dlg.exec_() == QDialog.Accepted:
            args, parms = dlg.generateParameters()
            project.setData("DOCUMENTATIONPARMS", "ERIC4API", parms)

            # now do the call
            dia = EricapiExecDialog("Ericapi")
            res = dia.start(args, project.ppath)
            if res:
                dia.exec_()

            outputFileName = parms["outputFile"]

            # add output files to the project data, if they aren't in already
            for progLanguage in parms["languages"]:
                if "%L" in outputFileName:
                    outfile = outputFileName.replace("%L", progLanguage)
                else:
                    if len(parms["languages"]) == 1:
                        outfile = outputFileName
                    else:
                        root, ext = os.path.splitext(outputFileName)
                        outfile = "%s-%s%s" % (root, progLanguage.lower(), ext)

                outfile = project.getRelativePath(outfile)
                if outfile not in project.pdata["OTHERS"]:
                    project.pdata["OTHERS"].append(outfile)
                    project.setDirty(True)
                    project.othersAdded(outfile)
 def __init__(self, forProject = False, taskViewer=None):
     """
     Constructor
     
     @param forProject flag indicating project related mode (boolean)
     @param taskViewer reference to the task viewer object
     """
     XMLHandlerBase.__init__(self)
     
     self.startDocumentSpecific = self.startDocumentTasks
     
     self.elements.update({
         'Tasks' : (self.startTasks, self.defaultEndElement),
         'Summary' : (self.defaultStartElement, self.endSummary),
         'Description' : (self.defaultStartElement, self.endDescription),
         'Created' : (self.defaultStartElement, self.endCreated),
         'Dir' : (self.defaultStartElement, self.endDir),
         'Name' : (self.defaultStartElement, self.endName),
         'Filename' : (self.startFilename, self.endFilename),
         'Linenumber' : (self.defaultStartElement, self.endLinenumber),
         'Task' : (self.startTask, self.endTask),
     })
 
     self.forProject = forProject
     if taskViewer:
         self.taskViewer = taskViewer
     else:
         self.taskViewer = e4App().getObject("TaskViewer")
예제 #16
0
    def __init__(self):
        """
        Constructor
        """
        ConfigurationPageBase.__init__(self)
        self.setupUi(self)
        self.setObjectName("EditorAPIsPage")

        self.prepareApiButton.setText(self.trUtf8("Compile APIs"))
        self.__apisManager = APIsManager()
        self.__currentAPI = None
        self.__inPreparation = False

        self.apiFileCompleter = E4FileCompleter(self.apiFileEdit)

        # set initial values
        self.pluginManager = e4App().getObject("PluginManager")
        self.apiAutoPrepareCheckBox.setChecked(Preferences.getEditor("AutoPrepareAPIs"))

        self.apis = {}
        apiLanguages = [""] + QScintilla.Lexers.getSupportedLanguages().keys()
        apiLanguages.sort()
        for lang in apiLanguages:
            if lang != "Guessed":
                self.apiLanguageComboBox.addItem(lang)
        self.currentApiLanguage = QString("")
        self.on_apiLanguageComboBox_activated(self.currentApiLanguage)

        for lang in apiLanguages[1:]:
            self.apis[lang] = QStringList(Preferences.getEditorAPI(lang))
 def __init__(self):
     """
     Constructor
     """
     ConfigurationPageBase.__init__(self)
     self.setupUi(self)
     self.setObjectName("ViewmanagerPage")
     
     # set initial values
     self.pluginManager = e4App().getObject("PluginManager")
     self.viewmanagers = self.pluginManager.getPluginDisplayStrings("viewmanager")
     self.windowComboBox.clear()
     currentVm = Preferences.getViewManager()
     
     keys = self.viewmanagers.keys()
     keys.sort()
     for key in keys:
         self.windowComboBox.addItem(self.trUtf8(self.viewmanagers[key]), 
                                     QVariant(key))
     currentIndex = self.windowComboBox.findText(\
         self.trUtf8(self.viewmanagers[currentVm]))
     self.windowComboBox.setCurrentIndex(currentIndex)
     self.on_windowComboBox_activated(currentIndex)
     
     self.tabViewGroupBox.setTitle(self.trUtf8(self.viewmanagers["tabview"]))
     
     self.filenameLengthSpinBox.setValue(
         Preferences.getUI("TabViewManagerFilenameLength"))
     self.filenameOnlyCheckBox.setChecked(
         Preferences.getUI("TabViewManagerFilenameOnly"))
     self.recentFilesSpinBox.setValue(
         Preferences.getUI("RecentNumber"))
 def __init__(self):
     """
     Constructor
     """
     ConfigurationPageBase.__init__(self)
     self.setupUi(self)
     self.setObjectName("ProjectBrowserPage")
     
     self.projectBrowserColours = {}
     self.__currentProjectTypeIndex = 0
     
     # set initial values
     self.projectTypeCombo.addItem('', QVariant(''))
     self.__projectBrowserFlags = {'' : 0}
     try:
         projectTypes = e4App().getObject("Project").getProjectTypes()
         for projectType in sorted(projectTypes.keys()):
             self.projectTypeCombo.addItem(projectTypes[projectType], 
                                           QVariant(projectType))
             self.__projectBrowserFlags[projectType] = \
                 Preferences.getProjectBrowserFlags(projectType)
     except KeyError:
         self.pbGroup.setEnabled(False)
     
     self.projectBrowserColours["Highlighted"] = \
         self.initColour("Highlighted", self.pbHighlightedButton, 
             Preferences.getProjectBrowserColour)
     
     self.followEditorCheckBox.setChecked(\
         Preferences.getProject("FollowEditor"))
     self.hideGeneratedCheckBox.setChecked(\
         Preferences.getProject("HideGeneratedForms"))
예제 #19
0
def factory(vcs):
    """
    Modul factory function to generate the right vcs object.
    
    @param vcs name of the VCS system to be used (string)
    @return the instantiated VCS object
    """
    pluginManager = e4App().getObject("PluginManager")
    if pluginManager is None:
        # that should not happen
        vc = None
    
    vc = pluginManager.getPluginObject("version_control", vcs, maybeActive = True)
    if vc is None:
        # try alternative vcs interfaces assuming, that there is a common
        # indicator for the alternatives
        found = False
        for indicator, vcsData in pluginManager.getVcsSystemIndicators().items():
            for vcsSystem, vcsSystemDisplay in vcsData:
                if vcsSystem == vcs:
                    found = True
                    break
            
            if found:
                if len(vcsData) > 1:
                    for vcsSystem, vcsSystemDisplay in vcsData:
                        if vcsSystem != vcs:
                            vc = pluginManager.getPluginObject(
                                "version_control", vcsSystem, maybeActive = True)
                            if vc is not None:
                                break
                break
    return vc
예제 #20
0
 def __captionChange(self, cap, editor):
     """
     Private method to handle Caption change signals from the editor. 
     
     Updates the listview text to reflect the new caption information.
     
     @param cap Caption for the editor
     @param editor Editor to update the caption for
     """
     fn = editor.getFileName()
     if fn:
         if Preferences.getUI("TabViewManagerFilenameOnly"):
             txt = os.path.basename(fn)
         else:
             txt = e4App().getObject("Project").getRelativePath(fn)
         
         maxFileNameChars = Preferences.getUI("TabViewManagerFilenameLength")
         if len(txt) > maxFileNameChars:
             txt = "...%s" % txt[-maxFileNameChars:]
         if editor.isReadOnly():
             txt = self.trUtf8("%1 (ro)").arg(txt)
         
         index = self.indexOf(editor)
         if index > -1:
             self.setTabText(index, txt)
             self.setTabToolTip(index, fn)
예제 #21
0
 def _addView(self, win, fn = None, noName = ""):
     """
     Protected method to add a view (i.e. window)
     
     @param win editor window to be added
     @param fn filename of this editor
     @param noName name to be used for an unnamed editor (string or QString)
     """
     if fn is None:
         if not unicode(noName):
             self.untitledCount += 1
             noName = self.trUtf8("Untitled %1").arg(self.untitledCount)
         self.currentTabWidget.addTab(win, noName)
         win.setNoName(noName)
     else:
         if self.filenameOnly:
             txt = os.path.basename(fn)
         else:
             txt = e4App().getObject("Project").getRelativePath(fn)
         if len(txt) > self.maxFileNameChars:
             txt = "...%s" % txt[-self.maxFileNameChars:]
         if not QFileInfo(fn).isWritable():
             txt = self.trUtf8("%1 (ro)").arg(txt)
         self.currentTabWidget.addTab(win, txt)
         index = self.currentTabWidget.indexOf(win)
         self.currentTabWidget.setTabToolTip(index, fn)
     self.currentTabWidget.setCurrentWidget(win)
     win.show()
     win.setFocus()
     if fn:
         self.emit(SIGNAL('changeCaption'), unicode(fn))
         self.emit(SIGNAL('editorChanged'), unicode(fn))
     else:
         self.emit(SIGNAL('changeCaption'), "")
    def __getPredefinedVars(self):
        """
        Private method to return predefined variables.
        
        @return dictionary of predefined variables and their values
        """
        project = e4App().getObject("Project")
        editor = self.viewmanager.activeWindow()
        today = datetime.datetime.now().date()
        sepchar = str(Preferences.getTemplates("SeparatorChar"))
        if sepchar == '%':
            sepchar = '%%'
        keyfmt = sepchar + "%s" + sepchar
        varValues = {keyfmt % 'date': today.isoformat(),
                     keyfmt % 'year': str(today.year)}

        if project.name:
            varValues[keyfmt % 'project_name'] = project.name

        path_name = editor.getFileName()
        if path_name:
            dir_name, file_name = os.path.split(path_name)
            base_name, ext = os.path.splitext(file_name)
            if ext:
                ext = ext[1:]
            varValues.update({
                    keyfmt % 'path_name': path_name,
                    keyfmt % 'dir_name': dir_name,
                    keyfmt % 'file_name': file_name,
                    keyfmt % 'base_name': base_name,
                    keyfmt % 'ext': ext
            })
        return varValues
 def __clearErrors(self):
     """
     Private method to clear all error markers of open editors.
     """
     vm = e4App().getObject("ViewManager")
     openFiles = vm.getOpenFilenames()
     for file in openFiles:
         editor = vm.getOpenEditor(file)
         editor.clearSyntaxError()
예제 #24
0
    def __init__(self, ui):
        """
        Constructor
        
        @param ui reference to the user interface object (UI.UserInterface)
        """
        self.__ui = ui

        self.__subversionDefaults = {"StopLogOnCopy": 1, "LogLimit": 100, "CommitMessages": 20}

        from VcsPlugins.vcsPySvn.ProjectHelper import SvnProjectHelper

        self.__projectHelperObject = SvnProjectHelper(None, None)
        try:
            e4App().registerPluginObject(pluginTypename, self.__projectHelperObject, pluginType)
        except KeyError:
            pass  # ignore duplicate registration
        readShortcuts(pluginName=pluginTypename)
 def __editorSyntaxCheck(self):
     """
     Private slot to handle the syntax check context menu action of the editors.
     """
     editor = e4App().getObject("ViewManager").activeWindow()
     if editor is not None:
         self.__editorSyntaxCheckerDialog = SyntaxCheckerDialog()
         self.__editorSyntaxCheckerDialog.show()
         self.__editorSyntaxCheckerDialog.start(editor.getFileName(), 
                                                unicode(editor.text()))
예제 #26
0
 def writeXML(self):
     """
     Public method to write the XML to the file.
     """
     XMLWriterBase.writeXML(self)
     
     self._write('<!DOCTYPE Tasks SYSTEM "Tasks-%s.dtd">' % tasksFileFormatVersion)
     
     # add some generation comments
     if self.forProject:
         self._write("<!-- eric4 tasks file for project %s -->" % self.name)
         if Preferences.getProject("XMLTimestamp"):
             self._write("<!-- Saved: %s -->" % time.strftime('%Y-%m-%d, %H:%M:%S'))
     else:
         self._write("<!-- eric4 tasks file -->")
         self._write("<!-- Saved: %s -->" % time.strftime('%Y-%m-%d, %H:%M:%S'))
     
     # add the main tag
     self._write('<Tasks version="%s">' % tasksFileFormatVersion)
     
     # do the tasks
     if self.forProject:
         tasks = e4App().getObject("TaskViewer").getProjectTasks()
     else:
         tasks = e4App().getObject("TaskViewer").getGlobalTasks()
     for task in tasks:
         self._write('  <Task priority="%d" completed="%s" bugfix="%s">' % \
                     (task.priority, task.completed, task.isBugfixTask))
         self._write('    <Summary>%s</Summary>' % \
                     self.escape("%s" % task.description.strip()))
         self._write('    <Description>%s</Description>' % \
                     self.escape(self.encodedNewLines(task.longtext.strip())))
         self._write('    <Created>%s</Created>' % \
                     time.strftime("%Y-%m-%d, %H:%M:%S", time.localtime(task.created)))
         if task.filename:
             self._write('    <Resource>')
             self._write('      <Filename>%s</Filename>' % \
                 Utilities.fromNativeSeparators(task.filename))
             self._write('      <Linenumber>%d</Linenumber>' % task.lineno)
             self._write('    </Resource>')
         self._write('  </Task>')
     
     self._write('</Tasks>', newline = False)
예제 #27
0
 def shutdown(self):
     """
     Public method to shut down the object.
     
     This method does some preparations so the object can be deleted properly.
     It disconnects from the focusChanged signal in order to avoid trouble later
     on.
     """
     self.disconnect(e4App(), SIGNAL("focusChanged(QWidget*, QWidget*)"), 
                     self.__appFocusChanged)
 def expand(self):
     """
     Public method to expand the item.
     """
     self.deleteChildren()
     self.populated = True
     
     pathlist = [str(self.text(0))]
     par = self.parent()
     
     # step 1: get a pathlist up to the requested variable
     while par is not None:
         pathlist.insert(0, str(par.text(0)))
         par = par.parent()
     
     # step 2: request the variable from the debugger
     filter = e4App().getObject("DebugUI").variablesFilter(self.scope)
     e4App().getObject("DebugServer").remoteClientVariable(\
         self.scope, filter, pathlist, self.framenr)
 def __projectShowMenu(self, menuName, menu):
     """
     Private slot called, when the the project menu or a submenu is 
     about to be shown.
     
     @param menuName name of the menu to be shown (string)
     @param menu reference to the menu (QMenu)
     """
     if menuName == "Checks" and self.__projectAct is not None:
         self.__projectAct.setEnabled(\
             e4App().getObject("Project").getProjectLanguage() == "Python")
예제 #30
0
 def clearCachedState(self, name):
     """
     Public method to clear the cached VCS state of a file/directory.
     
     @param name name of the entry to be cleared (QString or string)
     """
     project = e4App().getObject("Project")
     key = project.getRelativePath(unicode(name))
     try:
         del self.reportedStates[key]
     except KeyError:
         pass