def __generatePythonCode(self):
     """
     Private slot to generate Python code as requested by the user.
     """
     # init some variables
     sourceImpl = []
     appendAtIndex = -1
     indentStr = "    "
     slotsCode = []
     
     if self.__module is None:
         # new file
         try:
             if self.project.getProjectLanguage() == "Python3":
                 tmplName = os.path.join(getConfig('ericCodeTemplatesDir'),
                                         "impl_pyqt.py3.tmpl")
             else:
                 if self.project.getProjectType() == "PySide":
                     tmplName = os.path.join(getConfig('ericCodeTemplatesDir'),
                                             "impl_pyside.py.tmpl")
                 else:
                     tmplName = os.path.join(getConfig('ericCodeTemplatesDir'),
                                             "impl_pyqt.py.tmpl")
             tmplFile = open(tmplName, 'rb')
             template = tmplFile.read()
             tmplFile.close()
         except IOError, why:
             KQMessageBox.critical(self,
                 self.trUtf8("Code Generation"),
                 self.trUtf8("""<p>Could not open the code template file "%1".</p>"""
                             """<p>Reason: %2</p>""")\
                     .arg(tmplName)\
                     .arg(str(why)),
                 QMessageBox.StandardButtons(\
                     QMessageBox.Ok))
             return
         
         objName = self.__objectName()
         if not objName.isEmpty():
             template = template\
                 .replace("$FORMFILE$", 
                          os.path.splitext(os.path.basename(self.formFile))[0])\
                 .replace("$FORMCLASS$", unicode(objName))\
                 .replace("$CLASSNAME$", unicode(self.classNameCombo.currentText()))\
                 .replace("$SUPERCLASS$", unicode(self.__className()))
             
             sourceImpl = template.splitlines(True)
             appendAtIndex = -1
             
             # determine indent string
             for line in sourceImpl:
                 if line.lstrip().startswith("def __init__"):
                     indentStr = line.replace(line.lstrip(), "")
                     break
 def storeData(self):
     """
     Public method to store the entered/modified data.
     """
     self.project.debugProperties["INTERPRETER"] = \
         unicode(self.interpreterEdit.text())
     if not self.project.debugProperties["INTERPRETER"]:
         if self.project.pdata["PROGLANGUAGE"][0] in ["Python", "Python3"]:
             self.project.debugProperties["INTERPRETER"] = sys.executable
         elif self.project.pdata["PROGLANGUAGE"][0] == "Ruby":
             self.project.debugProperties["INTERPRETER"] = "/usr/bin/ruby"
     
     self.project.debugProperties["DEBUGCLIENT"] = \
         unicode(self.debugClientEdit.text())
     if not self.project.debugProperties["DEBUGCLIENT"]:
         if self.project.pdata["PROGLANGUAGE"][0] == "Python":
             debugClient = os.path.join(getConfig('ericDir'), 
                                        "DebugClients", "Python", "DebugClient.py")
         elif self.project.pdata["PROGLANGUAGE"][0] == "Python3":
             debugClient = os.path.join(getConfig('ericDir'), 
                                        "DebugClients", "Python3", "DebugClient.py")
         elif self.project.pdata["PROGLANGUAGE"][0] == "Ruby":
             debugClient = os.path.join(getConfig('ericDir'), 
                 "DebugClients", "Ruby", "DebugClient.rb")
         else:
             debugClient = ""
         self.project.debugProperties["DEBUGCLIENT"] = debugClient
     
     self.project.debugProperties["ENVIRONMENTOVERRIDE"] = \
         self.debugEnvironmentOverrideCheckBox.isChecked()
     self.project.debugProperties["ENVIRONMENTSTRING"] = \
         unicode(self.debugEnvironmentEdit.text())
     self.project.debugProperties["REMOTEDEBUGGER"] = \
         self.remoteDebuggerGroup.isChecked()
     self.project.debugProperties["REMOTEHOST"] = \
         unicode(self.remoteHostEdit.text())
     self.project.debugProperties["REMOTECOMMAND"] = \
         unicode(self.remoteCommandEdit.text())
     self.project.debugProperties["PATHTRANSLATION"] = \
         self.pathTranslationGroup.isChecked()
     self.project.debugProperties["REMOTEPATH"] = \
         unicode(self.translationRemoteEdit.text())
     self.project.debugProperties["LOCALPATH"] = \
         unicode(self.translationLocalEdit.text())
     self.project.debugProperties["CONSOLEDEBUGGER"] = \
         self.consoleDebuggerGroup.isChecked()
     self.project.debugProperties["CONSOLECOMMAND"] = \
         unicode(self.consoleCommandEdit.text())
     self.project.debugProperties["REDIRECT"] = \
         self.redirectCheckBox.isChecked()
     self.project.debugProperties["NOENCODING"] = \
         self.noEncodingCheckBox.isChecked()
     self.project.debugPropertiesLoaded = True
Example #3
0
def loadTranslators(qtTransDir, app, translationFiles = ()):
    """
    Function to load all required translations.
    
    @param qtTransDir directory of the Qt translations files (string)
    @param app reference to the application object (QApplication)
    @param translationFiles tuple of additional translations to
        be loaded (tuple of strings)
    @return the requested locale (string)
    """
    translations = ("qt", "eric4") + translationFiles
    loc = Preferences.getUILanguage()
    if loc is None:
        return

    if loc == "System":
        loc = str(QLocale.system().name())
    if loc != "C":
        dirs = [getConfig('ericTranslationsDir'), Utilities.getConfigDir()]
        if qtTransDir is not None:
            dirs.append(qtTransDir)

        loca = loc
        for tf in ["%s_%s" % (tr, loc) for tr in translations]:
            translator, ok = loadTranslatorForLocale(dirs, tf)
            loaded_translators[tf] = translator
            if ok:
                app.installTranslator(translator)
            else:
                if tf.startswith("eric4"):
                    loca = None
        loc = loca
    else:
        loc = None
    return loc
 def generateParameters(self):
     """
     Public method that generates the commandline parameters.
     
     It generates a QStringList to be used
     to set the QProcess arguments for the ericapi call and
     a list containing the non default parameters. The second
     list can be passed back upon object generation to overwrite
     the default settings.
     
     @return a tuple of the commandline parameters and non default parameters
         (QStringList, dictionary)
     """
     parms = {}
     args = QStringList()
     
     # 1. the program name
     args.append(sys.executable)
     args.append(Utilities.normabsjoinpath(getConfig('ericDir'), "eric4_api.py"))
     
     # 2. the commandline options
     if self.parameters['outputFile'] != self.defaults['outputFile']:
         parms['outputFile'] = self.parameters['outputFile']
         args.append('-o')
         if os.path.isabs(self.parameters['outputFile']):
             args.append(self.parameters['outputFile'])
         else:
             args.append(os.path.join(self.ppath, self.parameters['outputFile']))
     if self.parameters['basePackage'] != self.defaults['basePackage']:
         parms['basePackage'] = self.parameters['basePackage']
         args.append('-b')
         args.append(self.parameters['basePackage'])
     if self.parameters['ignoreDirectories'] != self.defaults['ignoreDirectories']:
         parms['ignoreDirectories'] = self.parameters['ignoreDirectories'][:]
         for d in self.parameters['ignoreDirectories']:
             args.append('-x')
             args.append(d)
     if self.parameters['ignoreFilePatterns'] != self.defaults['ignoreFilePatterns']:
         parms['ignoreFilePatterns'] = self.parameters['ignoreFilePatterns'][:]
         for pattern in self.parameters['ignoreFilePatterns']:
             args.append("--exclude-file=%s" % pattern)
     if self.parameters['useRecursion'] != self.defaults['useRecursion']:
         parms['useRecursion'] = self.parameters['useRecursion']
         args.append('-r')
     if self.parameters['sourceExtensions'] != self.defaults['sourceExtensions']:
         parms['sourceExtensions'] = self.parameters['sourceExtensions'][:]
         for ext in self.parameters['sourceExtensions']:
             args.append('-t')
             args.append(ext)
     if self.parameters['newStyle'] != self.defaults['newStyle']:
         parms['newStyle'] = self.parameters['newStyle']
         args.append('--oldstyle')
     if self.parameters['includePrivate'] != self.defaults['includePrivate']:
         parms['includePrivate'] = self.parameters['includePrivate']
         args.append('-p')
     parms['languages'] = self.parameters['languages'][:]
     for lang in self.parameters['languages']:
         args.append('--language=%s' % lang)
     
     return (args, parms)
Example #5
0
    def resolveEntity(self, publicId, systemId):
        """
        Public method to resolve the system identifier of an entity and
        return either the system identifier to read from as a string.
        
        @param publicId publicId of an entity (string)
        @param systemId systemId of an entity to reslove (string)
        @return resolved systemId (string)
        """
        if systemId.startswith("http://"):
            sId = systemId

        elif os.path.exists(systemId):
            sId = systemId

        else:
            dtdDir = getConfig("ericDTDDir")
            if not os.path.isabs(dtdDir):
                dtdDir = os.path.abspath(dtdDir)
            sId = os.path.join(dtdDir, systemId)
            if not os.path.exists(sId):
                ind = sId.rfind("-")
                if ind != -1:
                    sId = "%s.dtd" % sId[:ind]
                if not os.path.exists(sId):
                    sId = ""

        return sId
Example #6
0
 def __init__(self):
     """
     Constructor
     """
     ericPic = QPixmap(os.path.join(getConfig("ericPixDir"), "ericSplash.png"))
     self.labelAlignment = Qt.Alignment(Qt.AlignBottom | Qt.AlignRight | Qt.AlignAbsolute)
     QSplashScreen.__init__(self, ericPic)
     self.show()
     QApplication.flush()
 def __installEric4Doc(self, engine):
     """
     Private method to install/update the eric4 help documentation.
     
     @param engine reference to the help engine (QHelpEngineCore)
     @return flag indicating success (boolean)
     """
     versionKey = QString("eric4_ide")
     info = engine.customValue(versionKey, QVariant("")).toString()
     lst = info.split('|')
     
     dt = QDateTime()
     if len(lst) and not lst[0].isEmpty():
         dt = QDateTime.fromString(lst[0], Qt.ISODate)
     
     qchFile = QString()
     if len(lst) == 2:
         qchFile = lst[1]
     
     docsPath = QDir(QString(getConfig("ericDocDir")) + QDir.separator() + "Help")
     
     files = docsPath.entryList(QStringList("*.qch"))
     if files.isEmpty():
         engine.setCustomValue(versionKey, 
             QVariant(QDateTime().toString(Qt.ISODate) + '|'))
         return False
     
     for f in files:
         if f == "source.qch":
             fi = QFileInfo(docsPath.absolutePath() + QDir.separator() + f)
             if dt.isValid() and \
                fi.lastModified().toString(Qt.ISODate) == dt.toString(Qt.ISODate) and \
                qchFile == fi.absoluteFilePath():
                 return False
             
             namespace = QHelpEngineCore.namespaceName(fi.absoluteFilePath())
             if namespace.isEmpty():
                 continue
             
             if namespace in engine.registeredDocumentations():
                 engine.unregisterDocumentation(namespace)
             
             if not engine.registerDocumentation(fi.absoluteFilePath()):
                 self.emit(SIGNAL("errorMessage(const QString&)"), 
                     self.trUtf8("""<p>The file <b>%1</b> could not be registered."""
                                 """<br/>Reason: %2</p>""")\
                         .arg(fi.absoluteFilePath)\
                         .arg(engine.error())
                 )
                 return False
             
             engine.setCustomValue(versionKey, 
                 QVariant(fi.lastModified().toString(Qt.ISODate) + '|' + \
                 fi.absoluteFilePath()))
             return True
     
     return False
Example #8
0
def initializeResourceSearchPath():
    """
    Function to initialize the default mime source factory.
    """
    defaultIconPath = os.path.join(getConfig('ericIconDir'), "default")
    iconPaths = Preferences.getIcons("Path")
    for iconPath in iconPaths:
        if not iconPath.isEmpty():
            UI.PixmapCache.addSearchPath(iconPath)
    if not defaultIconPath in iconPaths:
        UI.PixmapCache.addSearchPath(defaultIconPath)
 def on_cssButton_clicked(self):
     """
     Private slot to select a css style sheet.
     """
     cssFile = KQFileDialog.getOpenFileName(\
         self,
         self.trUtf8("Select CSS style sheet"),
         getConfig('ericCSSDir'),
         self.trUtf8("Style sheet (*.css);;All files (*)"))
         
     if not cssFile.isEmpty():
         # make it relative, if it is in a subdirectory of the project path 
         cf = unicode(Utilities.toNativeSeparators(cssFile))
         cf = self.project.getRelativePath(cf)
         self.cssEdit.setText(cf)
Example #10
0
def installTranslations():
    """
    Install the translation files into the right place.
    """
    global privateInstall, configDir
    
    if privateInstall:
        targetDir = configDir
    else:
        targetDir = getConfig('ericTranslationsDir')
    
    try:
        for fn in glob.glob(os.path.join('eric', 'i18n', '*.qm')):
            shutil.copy2(fn, targetDir)
            os.chmod(os.path.join(targetDir, os.path.basename(fn)), 0o644)
    except IOError, msg:
        sys.stderr.write('IOError: %s\nTry install-i18n as root.\n' % msg)
 def __startPluginInstall(self):
     """
     Private slot to start the eric4 plugin installation dialog.
     """
     proc = QProcess()
     applPath = os.path.join(getConfig("ericDir"), "eric4_plugininstall.py")
     
     args = QStringList()
     args.append(applPath)
     args += self.cw.getDownloadedPlugins()
     
     if not os.path.isfile(applPath) or not proc.startDetached(sys.executable, args):
         KQMessageBox.critical(self,
             self.trUtf8('Process Generation Error'),
             self.trUtf8(
                 '<p>Could not start the process.<br>'
                 'Ensure that it is available as <b>%1</b>.</p>'
             ).arg(applPath),
             self.trUtf8('OK'))
     
     self.close()
 def __populateLanguageCombo(self):
     """
     Private method to initialize the language combobox of the Interface 
     configuration page.
     """
     self.languageComboBox.clear()
     
     fnlist = glob.glob("eric4_*.qm") + \
         glob.glob(os.path.join(getConfig('ericTranslationsDir'), "eric4_*.qm")) + \
         glob.glob(os.path.join(Utilities.getConfigDir(), "eric4_*.qm"))
     locales = {}
     for fn in fnlist:
         locale = os.path.basename(fn)[6:-3]
         if not locales.has_key(locale):
             translator = QTranslator()
             translator.load(fn)
             locales[locale] = \
                 translator.translate("InterfacePage", "English", 
                                      "Translate this with your language") + \
                 QString(" (%1)").arg(locale)
     localeList = locales.keys()
     localeList.sort()
     
     try:
         uiLanguage = unicode(Preferences.getUILanguage())
         if uiLanguage == "None":
             currentIndex = 0
         elif uiLanguage == "System":
             currentIndex = 1
         else:
             currentIndex = localeList.index(uiLanguage) + 2
     except ValueError:
         currentIndex = 0
     self.languageComboBox.clear()
     
     self.languageComboBox.addItem("English (default)", QVariant("None"))
     self.languageComboBox.addItem(self.trUtf8('System'), QVariant("System"))
     for locale in localeList:
         self.languageComboBox.addItem(locales[locale], QVariant(locale))
     self.languageComboBox.setCurrentIndex(currentIndex)
Example #13
0
def exeDisplayData():
    """
    Public method to support the display of some executable info.
    
    @return dictionary containing the data to query the presence of
        the executable
    """
    exe = "eric4_api"
    if Utilities.isWindowsPlatform():
        exe = os.path.join(getConfig("bindir"), exe + ".bat")

    data = {
        "programEntry": True,
        "header": QApplication.translate("EricapiPlugin", "Eric4 API File Generator"),
        "exe": exe,
        "versionCommand": "--version",
        "versionStartsWith": "eric4_",
        "versionPosition": -2,
        "version": "",
        "versionCleanup": None,
    }

    return data
Example #14
0
 def __startProc(self, applName, *applArgs):
     """
     Private method to start an eric4 application.
     
     @param applName name of the eric4 application script (string)
     @param *applArgs variable list of application arguments
     """
     proc = QProcess()
     applPath = os.path.join(getConfig("ericDir"), applName)
     
     args = QStringList()
     args.append(applPath)
     for arg in applArgs:
         args.append(unicode(arg))
     
     if not os.path.isfile(applPath) or not proc.startDetached(sys.executable, args):
         QMessageBox.critical(self,
             self.trUtf8('Process Generation Error'),
             self.trUtf8(
                 '<p>Could not start the process.<br>'
                 'Ensure that it is available as <b>%1</b>.</p>'
             ).arg(applPath),
             self.trUtf8('OK'))
 def __init__(self, vm):
     """
     Constructor
     
     @param vm view manager widget (Tabview)
     """
     E4TabWidget.__init__(self)
     self.setAttribute(Qt.WA_DeleteOnClose, True)
     
     self.__tabBar = TabBar(self)
     self.setTabBar(self.__tabBar)
     
     self.setUsesScrollButtons(True)
     self.setElideMode(Qt.ElideNone)
     if isMacPlatform():
         self.setDocumentMode(True)
     
     self.connect(self.__tabBar, SIGNAL("tabMoveRequested(int, int)"), 
                  self.moveTab)
     self.connect(self.__tabBar, SIGNAL("tabRelocateRequested(long, int, int)"), 
                  self.relocateTab)
     self.connect(self.__tabBar, SIGNAL("tabCopyRequested(long, int, int)"), 
                  self.copyTabOther)
     self.connect(self.__tabBar, SIGNAL("tabCopyRequested(int, int)"), 
                  self.copyTab)
     
     self.vm = vm
     self.editors = []
     
     self.indicator = E4Led(self)
     self.setCornerWidget(self.indicator, Qt.TopLeftCorner)
     
     self.rightCornerWidget = QWidget(self)
     self.rightCornerWidgetLayout = QHBoxLayout(self.rightCornerWidget)
     self.rightCornerWidgetLayout.setMargin(0)
     self.rightCornerWidgetLayout.setSpacing(0)
     
     self.__navigationMenu = QMenu(self)
     self.connect(self.__navigationMenu, SIGNAL("aboutToShow()"), 
                  self.__showNavigationMenu)
     self.connect(self.__navigationMenu, SIGNAL("triggered(QAction*)"), 
                  self.__navigationMenuTriggered)
     
     self.navigationButton = QToolButton(self)
     self.navigationButton.setIcon(UI.PixmapCache.getIcon("1downarrow.png"))
     self.navigationButton.setToolTip(self.trUtf8("Show a navigation menu"))
     self.navigationButton.setPopupMode(QToolButton.InstantPopup)
     self.navigationButton.setMenu(self.__navigationMenu)
     self.navigationButton.setEnabled(False)
     self.rightCornerWidgetLayout.addWidget(self.navigationButton)
     
     if Preferences.getUI("SingleCloseButton") or \
        not hasattr(self, 'setTabsClosable'):
         self.closeButton = QToolButton(self)
         self.closeButton.setIcon(UI.PixmapCache.getIcon("close.png"))
         self.closeButton.setToolTip(self.trUtf8("Close the current editor"))
         self.closeButton.setEnabled(False)
         self.connect(self.closeButton, SIGNAL("clicked(bool)"),
             self.__closeButtonClicked)
         self.rightCornerWidgetLayout.addWidget(self.closeButton)
     else:
         self.connect(self, SIGNAL("tabCloseRequested(int)"), 
             self.__closeRequested)
         self.closeButton = None
     
     self.setCornerWidget(self.rightCornerWidget, Qt.TopRightCorner)
     
     self.__initMenu()
     self.contextMenuEditor = None
     self.contextMenuIndex = -1
     
     self.setTabContextMenuPolicy(Qt.CustomContextMenu)
     self.connect(self, SIGNAL('customTabContextMenuRequested(const QPoint &, int)'),
                  self.__showContextMenu)
     
     ericPic = QPixmap(os.path.join(getConfig('ericPixDir'), 'eric_small.png'))
     self.emptyLabel = QLabel()
     self.emptyLabel.setPixmap(ericPic)
     self.emptyLabel.setAlignment(Qt.AlignVCenter | Qt.AlignHCenter)
     E4TabWidget.addTab(self, self.emptyLabel, UI.PixmapCache.getIcon("empty.png"), "")
 def generateParameters(self):
     """
     Public method that generates the commandline parameters.
     
     It generates a QStringList to be used
     to set the QProcess arguments for the ericdoc call and
     a list containing the non default parameters. The second
     list can be passed back upon object generation to overwrite
     the default settings.
     
     @return a tuple of the commandline parameters and non default parameters
         (QStringList, dictionary)
     """
     parms = {}
     args = QStringList()
     
     # 1. the program name
     args.append(sys.executable)
     args.append(Utilities.normabsjoinpath(getConfig('ericDir'), "eric4_doc.py"))
     
     # 2. the commandline options
     # 2a. general commandline options
     if self.parameters['outputDirectory'] != self.defaults['outputDirectory']:
         parms['outputDirectory'] = self.parameters['outputDirectory']
         args.append('-o')
         if os.path.isabs(self.parameters['outputDirectory']):
             args.append(self.parameters['outputDirectory'])
         else:
             args.append(os.path.join(self.ppath, self.parameters['outputDirectory']))
     if self.parameters['ignoreDirectories'] != self.defaults['ignoreDirectories']:
         parms['ignoreDirectories'] = self.parameters['ignoreDirectories'][:]
         for d in self.parameters['ignoreDirectories']:
             args.append('-x')
             args.append(d)
     if self.parameters['ignoreFilePatterns'] != self.defaults['ignoreFilePatterns']:
         parms['ignoreFilePatterns'] = self.parameters['ignoreFilePatterns'][:]
         for pattern in self.parameters['ignoreFilePatterns']:
             args.append("--exclude-file=%s" % pattern)
     if self.parameters['useRecursion'] != self.defaults['useRecursion']:
         parms['useRecursion'] = self.parameters['useRecursion']
         args.append('-r')
     if self.parameters['noindex'] != self.defaults['noindex']:
         parms['noindex'] = self.parameters['noindex']
         args.append('-i')
     if self.parameters['noempty'] != self.defaults['noempty']:
         parms['noempty'] = self.parameters['noempty']
         args.append('-e')
     if self.parameters['sourceExtensions'] != self.defaults['sourceExtensions']:
         parms['sourceExtensions'] = self.parameters['sourceExtensions'][:]
         for ext in self.parameters['sourceExtensions']:
             args.append('-t')
             args.append(ext)
     
     # 2b. style commandline options
     if self.parameters['cssFile'] != self.defaults['cssFile']:
         parms['cssFile'] = self.parameters['cssFile']
         args.append('-c')
         if os.path.isabs(self.parameters['cssFile']):
             args.append(self.parameters['cssFile'])
         else:
             args.append(os.path.join(self.ppath, self.parameters['cssFile']))
     for key, value in self.colors.items():
         if self.colors[key] != eric4docDefaultColors[key]:
             parms[key] = self.colors[key]
             args.append("--%s=%s" % \
                         (eric4docColorParameterNames[key], self.colors[key]))
     
     # 2c. QtHelp commandline options
     parms['qtHelpEnabled'] = self.parameters['qtHelpEnabled']
     if self.parameters['qtHelpEnabled']:
         args.append('--create-qhp')
     if self.parameters['qtHelpOutputDirectory'] != \
        self.defaults['qtHelpOutputDirectory']:
         parms['qtHelpOutputDirectory'] = self.parameters['qtHelpOutputDirectory']
         if os.path.isabs(self.parameters['outputDirectory']):
             args.append("--qhp-outdir=%s" % self.parameters['qtHelpOutputDirectory'])
         else:
             args.append("--qhp-outdir=%s" % \
                 os.path.join(self.ppath, self.parameters['qtHelpOutputDirectory']))
     if self.parameters['qtHelpNamespace'] != self.defaults['qtHelpNamespace']:
         parms['qtHelpNamespace'] = self.parameters['qtHelpNamespace']
         args.append("--qhp-namespace=%s" % self.parameters['qtHelpNamespace'])
     if self.parameters['qtHelpVirtualFolder'] != self.defaults['qtHelpVirtualFolder']:
         parms['qtHelpVirtualFolder'] = self.parameters['qtHelpVirtualFolder']
         args.append("--qhp-virtualfolder=%s" % self.parameters['qtHelpVirtualFolder'])
     if self.parameters['qtHelpFilterName'] != self.defaults['qtHelpFilterName']:
         parms['qtHelpFilterName'] = self.parameters['qtHelpFilterName']
         args.append("--qhp-filtername=%s" % self.parameters['qtHelpFilterName'])
     if self.parameters['qtHelpFilterAttributes'] != \
        self.defaults['qtHelpFilterAttributes']:
         parms['qtHelpFilterAttributes'] = self.parameters['qtHelpFilterAttributes']
         args.append("--qhp-filterattribs=%s" % \
             self.parameters['qtHelpFilterAttributes'])
     if self.parameters['qtHelpTitle'] != self.defaults['qtHelpTitle']:
         parms['qtHelpTitle'] = self.parameters['qtHelpTitle']
         args.append("--qhp-title=%s" % self.parameters['qtHelpTitle'])
     if self.parameters['qtHelpCreateCollection'] != \
        self.defaults['qtHelpCreateCollection']:
         parms['qtHelpCreateCollection'] = self.parameters['qtHelpCreateCollection']
         args.append('--create-qhc')
     
     return (args, parms)
"""
Module implementing a debugger stub for remote debugging.
"""

import os
import sys
import distutils.sysconfig

from eric4config import getConfig

debugger = None
__scriptname = None

modDir = distutils.sysconfig.get_python_lib(True)
ericpath = os.getenv('ERICDIR', getConfig('ericDir'))

if not ericpath in sys.path:
    sys.path.insert(-1, ericpath)
    
def initDebugger(kind = "standard"):
    """
    Module function to initialize a debugger for remote debugging.
    
    @param kind type of debugger ("standard" or "threads")
    @return flag indicating success (boolean)
    """
    global debugger
    res = 1
    try:
        if kind == "standard":
Example #18
0
def cleanUp():
    """
    Uninstall the old eric files.
    """
    global macAppBundleName, macAppBundlePath, platBinDir
    
    try:
        from eric4config import getConfig
    except ImportError:
        # eric4 wasn't installed previously
        return
    
    global pyModDir, progLanguages
    
    # Remove the menu entry for Linux systems
    if sys.platform.startswith("linux") and os.getuid() == 0:
        for name in ["/usr/share/pixmaps/eric4.png",
                     "/usr/share/applications/eric4.desktop",
                     "/usr/share/appdata/eric4.appdata.xml"]:
            if os.path.exists(name):
                os.remove(name)
    
    # Remove the wrapper scripts
    rem_wnames = [
        "eric4-api", "eric4-compare",
        "eric4-configure", "eric4-diff",
        "eric4-doc", "eric4-helpviewer",
        "eric4-qregexp", "eric4-re", 
        "eric4-trpreviewer", "eric4-uipreviewer",
        "eric4-unittest", "eric4",
        "eric4-tray", "eric4-editor", 
        "eric4-plugininstall", "eric4-pluginuninstall", 
        "eric4-pluginrepository", "eric4-sqlbrowser", 
        "eric4-webbrowser", "eric4-iconeditor", 
        "eric4_api", "eric4_compare",
        "eric4_configure", "eric4_diff",
        "eric4_doc", "eric4_helpviewer",
        "eric4_qregexp", "eric4_re", 
        "eric4_trpreviewer", "eric4_uipreviewer",
        "eric4_unittest", "eric4",
        "eric4_tray", "eric4_editor", 
        "eric4_plugininstall", "eric4_pluginuninstall", 
        "eric4_pluginrepository", "eric4_sqlbrowser", 
        "eric4_webbrowser", "eric4_iconeditor", 
    ]
    
    try:
        for rem_wname in rem_wnames:
            rwname = wrapperName(getConfig('bindir'), rem_wname)
            if os.path.exists(rwname):
                os.remove(rwname)
        
        # Cleanup our config file(s)
        for name in ['eric4config.py', 'eric4config.pyc', 'eric4.pth']:
            e4cfile = os.path.join(pyModDir, name)
            if os.path.exists(e4cfile):
                os.remove(e4cfile)
            
        # Cleanup the install directories
        for name in ['ericExamplesDir', 'ericDocDir', 'ericDTDDir', 'ericCSSDir',
                     'ericIconDir', 'ericPixDir', 'ericDir', 'ericTemplatesDir',
                     'ericCodeTemplatesDir', 'ericOthersDir', 'ericStylesDir']:
            if os.path.exists(getConfig(name)):
                shutil.rmtree(getConfig(name), True)
        
        # Cleanup translations
        for name in glob.glob(os.path.join(getConfig('ericTranslationsDir'), 'eric4_*.qm')):
            if os.path.exists(name):
                os.remove(name)
        
        # Cleanup API files
        try:
            apidir = getConfig('apidir')
            for progLanguage in progLanguages:
                for name in getConfig('apis'):
                    apiname = os.path.join(apidir, progLanguage, name)
                    if os.path.exists(apiname):
                        os.remove(apiname)
        except AttributeError:
            pass
        
        if sys.platform == "darwin":
            # delete the Mac app bundle
            if os.path.exists("/Developer/Applications/Eric4"):
                shutil.rmtree("/Developer/Applications/Eric4")
            try:
                macAppBundlePath = getConfig("macAppBundlePath")
                macAppBundleName = getConfig("macAppBundleName")
            except AttributeError:
                macAppBundlePath = "/Applications"
                macAppBundleName = "eric4.app"
            if os.path.exists("/Applications/" + macAppBundleName):
                shutil.rmtree("/Applications/" + macAppBundleName)
            bundlePath = os.path.join(macAppBundlePath, macAppBundleName)
            if os.path.exists(bundlePath):
                shutil.rmtree(bundlePath)
        
    except IOError, msg:
        sys.stderr.write('IOError: %s\nTry install with admin rights.\n' % msg)
        exit(7)
 def __init__(self, parent = None, doLoadPlugins = True, develPlugin = None):
     """
     Constructor
     
     The Plugin Manager deals with three different plugin directories.
     The first is the one, that is part of eric4 (eric4/Plugins). The
     second one is the global plugin directory called 'eric4plugins', 
     which is located inside the site-packages directory. The last one
     is the user plugin directory located inside the .eric4 directory
     of the users home directory.
     
     @param parent reference to the parent object (QObject)
     @keyparam doLoadPlugins flag indicating, that plugins should 
         be loaded (boolean)
     @keyparam develPlugin filename of a plugin to be loaded for 
         development (string)
     """
     QObject.__init__(self, parent)
     
     self.__ui = parent
     self.__develPluginFile = develPlugin
     self.__develPluginName = None
     
     self.__inactivePluginsKey = "PluginManager/InactivePlugins"
     
     self.pluginDirs = {
         "eric4"  : os.path.join(getConfig('ericDir'), "Plugins"), 
         "global" : os.path.join(Utilities.getPythonModulesDirectory(), 
                                 "eric4plugins"), 
         "user"   : os.path.join(Utilities.getConfigDir(), "eric4plugins"), 
     }
     self.__priorityOrder = ["eric4", "global", "user"]
     
     self.__defaultDownloadDir = os.path.join(Utilities.getConfigDir(), "Downloads")
     
     self.__activePlugins = {}
     self.__inactivePlugins = {}
     self.__onDemandActivePlugins = {}
     self.__onDemandInactivePlugins = {}
     self.__activeModules = {}
     self.__inactiveModules = {}
     self.__onDemandActiveModules = {}
     self.__onDemandInactiveModules = {}
     self.__failedModules = {}
     
     self.__foundCoreModules = []
     self.__foundGlobalModules = []
     self.__foundUserModules = []
     
     self.__modulesCount = 0
     
     pdirsExist, msg = self.__pluginDirectoriesExist()
     if not pdirsExist:
         raise PluginPathError(msg)
     
     if doLoadPlugins:
         if not self.__pluginModulesExist():
             raise PluginModulesError
         
         self.__insertPluginsPaths()
         
         self.__loadPlugins()
     
     self.__checkPluginsDownloadDirectory()
 def __init__(self, project, parent = None, name = None):
     """
     Constructor
     
     @param project reference to the project object
     @param parent parent widget of this dialog (QWidget)
     @param name name of this dialog (string or QString)
     """
     QDialog.__init__(self, parent)
     if name:
         self.setObjectName(name)
     self.setupUi(self)
     
     self.debugClientCompleter = E4FileCompleter(self.debugClientEdit)
     self.interpreterCompleter = E4FileCompleter(self.interpreterEdit)
     self.translationLocalCompleter = E4DirCompleter(self.translationLocalEdit)
     
     self.project = project
     
     if self.project.debugProperties["INTERPRETER"]:
         self.interpreterEdit.setText(self.project.debugProperties["INTERPRETER"])
     else:
         if self.project.pdata["PROGLANGUAGE"][0] in ["Python", "Python3"]:
             self.interpreterEdit.setText(sys.executable)
         elif self.project.pdata["PROGLANGUAGE"][0] == "Ruby":
             self.interpreterEdit.setText("/usr/bin/ruby")
     if self.project.debugProperties["DEBUGCLIENT"]:
         self.debugClientEdit.setText(self.project.debugProperties["DEBUGCLIENT"])
     else:
         if self.project.pdata["PROGLANGUAGE"][0] == "Python":
             debugClient = os.path.join(getConfig('ericDir'), 
                                        "DebugClients", "Python", "DebugClient.py")
         elif self.project.pdata["PROGLANGUAGE"][0] == "Python3":
             debugClient = os.path.join(getConfig('ericDir'), 
                                        "DebugClients", "Python3", "DebugClient.py")
         elif self.project.pdata["PROGLANGUAGE"][0] == "Ruby":
             debugClient = os.path.join(getConfig('ericDir'), 
                 "DebugClients", "Ruby", "DebugClient.rb")
         else:
             debugClient = ""
         self.debugClientEdit.setText(debugClient)
     self.debugEnvironmentOverrideCheckBox.setChecked(\
         self.project.debugProperties["ENVIRONMENTOVERRIDE"])
     self.debugEnvironmentEdit.setText(\
         self.project.debugProperties["ENVIRONMENTSTRING"])
     self.remoteDebuggerGroup.setChecked(\
         self.project.debugProperties["REMOTEDEBUGGER"])
     self.remoteHostEdit.setText(\
         self.project.debugProperties["REMOTEHOST"])
     self.remoteCommandEdit.setText(\
         self.project.debugProperties["REMOTECOMMAND"])
     self.pathTranslationGroup.setChecked(\
         self.project.debugProperties["PATHTRANSLATION"])
     self.translationRemoteEdit.setText(\
         self.project.debugProperties["REMOTEPATH"])
     self.translationLocalEdit.setText(\
         self.project.debugProperties["LOCALPATH"])
     self.consoleDebuggerGroup.setChecked(\
         self.project.debugProperties["CONSOLEDEBUGGER"])
     self.consoleCommandEdit.setText(\
         self.project.debugProperties["CONSOLECOMMAND"])
     self.redirectCheckBox.setChecked(\
         self.project.debugProperties["REDIRECT"])
     self.noEncodingCheckBox.setChecked(\
         self.project.debugProperties["NOENCODING"])
Example #21
0
    def startRemote(self, port, runInConsole):
        """
        Public method to start a remote Python interpreter.
        
        @param port portnumber the debug server is listening on (integer)
        @param runInConsole flag indicating to start the debugger in a 
            console window (boolean)
        @return client process object (QProcess) and a flag to indicate
            a network connection (boolean)
        """
        interpreter = unicode(Preferences.getDebugger("Python3Interpreter"))
        if interpreter == "":
            KQMessageBox.critical(None,
                self.trUtf8("Start Debugger"),
                self.trUtf8(\
                    """<p>No Python3 interpreter configured.</p>"""))
            return None, False

        debugClientType = unicode(Preferences.getDebugger("DebugClientType3"))
        if debugClientType == "standard":
            debugClient = os.path.join(
                getConfig('ericDir'), "DebugClients", "Python3",
                "DebugClient.py")
        elif debugClientType == "threaded":
            debugClient = os.path.join(
                getConfig('ericDir'), "DebugClients", "Python3",
                "DebugClientThreads.py")
        else:
            debugClient = unicode(Preferences.getDebugger("DebugClient3"))
            if debugClient == "":
                debugClient = os.path.join(sys.path[0], "DebugClients",
                                           "Python3", "DebugClient.py")

        redirect = str(Preferences.getDebugger("Python3Redirect"))
        noencoding = \
            Preferences.getDebugger("Python3NoEncoding") and '--no-encoding' or ''

        if Preferences.getDebugger("RemoteDbgEnabled"):
            ipaddr = self.debugServer.getHostAddress(False)
            rexec = unicode(Preferences.getDebugger("RemoteExecution"))
            rhost = unicode(Preferences.getDebugger("RemoteHost"))
            if rhost == "":
                rhost = "localhost"
            if rexec:
                args = Utilities.parseOptionString(rexec) + \
                       [rhost, interpreter, os.path.abspath(debugClient),
                        noencoding, str(port), redirect, ipaddr]
                args[0] = Utilities.getExecutablePath(args[0])
                process, error = self.__startProcess(args[0], args[1:])
                if process is None:
                    KQMessageBox.critical(None,
                        self.trUtf8("Start Debugger"),
                        self.trUtf8(\
                            """<p>The debugger backend could not be started.</p>"""
                            """<p>Reason: %1</p>""").arg(error))

                # set translation function
                if Preferences.getDebugger("PathTranslation"):
                    self.translateRemote = \
                        unicode(Preferences.getDebugger("PathTranslationRemote"))
                    self.translateLocal = \
                        unicode(Preferences.getDebugger("PathTranslationLocal"))
                    self.translate = self.__remoteTranslation
                else:
                    self.translate = self.__identityTranslation
                return process, self.__isNetworked

        # set translation function
        self.translate = self.__identityTranslation

        # setup the environment for the debugger
        if Preferences.getDebugger("DebugEnvironmentReplace"):
            clientEnv = {}
        else:
            clientEnv = os.environ.copy()
        envlist = Utilities.parseEnvironmentString(\
            Preferences.getDebugger("DebugEnvironment"))
        for el in envlist:
            try:
                key, value = el.split('=', 1)
                if value.startswith('"') or value.startswith("'"):
                    value = value[1:-1]
                clientEnv[str(key)] = str(value)
            except UnpackError:
                pass

        ipaddr = self.debugServer.getHostAddress(True)
        if runInConsole or Preferences.getDebugger("ConsoleDbgEnabled"):
            ccmd = unicode(Preferences.getDebugger("ConsoleDbgCommand"))
            if ccmd:
                args = Utilities.parseOptionString(ccmd) + \
                       [interpreter, os.path.abspath(debugClient),
                        noencoding, str(port), '0', ipaddr]
                args[0] = Utilities.getExecutablePath(args[0])
                process, error = self.__startProcess(args[0], args[1:],
                                                     clientEnv)
                if process is None:
                    KQMessageBox.critical(None,
                        self.trUtf8("Start Debugger"),
                        self.trUtf8(\
                            """<p>The debugger backend could not be started.</p>"""
                            """<p>Reason: %1</p>""").arg(error))
                return process, self.__isNetworked

        process, error = self.__startProcess(
            interpreter,
            [debugClient, noencoding,
             str(port), redirect, ipaddr], clientEnv)
        if process is None:
            KQMessageBox.critical(
                None, self.trUtf8("Start Debugger"),
                self.trUtf8(
                    """<p>The debugger backend could not be started.</p>"""
                    """<p>Reason: %1</p>""").arg(error))
        return process, self.__isNetworked
    def __setupUi(self):
        """
        Private method to perform the general setup of the configuration widget.
        """
        self.setObjectName("ConfigurationDialog")
        self.resize(900, 650)
        self.setProperty("sizeGripEnabled", QVariant(True))
        self.verticalLayout_2 = QVBoxLayout(self)
        self.verticalLayout_2.setSpacing(6)
        self.verticalLayout_2.setMargin(6)
        self.verticalLayout_2.setObjectName("verticalLayout_2")
        
        self.configSplitter = QSplitter(self)
        self.configSplitter.setOrientation(Qt.Horizontal)
        self.configSplitter.setObjectName("configSplitter")
        
        self.configListWidget = QWidget(self.configSplitter)
        self.leftVBoxLayout = QVBoxLayout(self.configListWidget)
        self.leftVBoxLayout.setMargin(0)
        self.leftVBoxLayout.setSpacing(0)
        self.leftVBoxLayout.setObjectName("leftVBoxLayout")
        self.configListFilter = E4LineEdit(self, self.trUtf8("Enter filter text..."))
        self.configListFilter.setObjectName("configListFilter")
        self.leftVBoxLayout.addWidget(self.configListFilter)
        self.configList = QTreeWidget()
        self.configList.setObjectName("configList")
        self.leftVBoxLayout.addWidget(self.configList)
        self.connect(self.configListFilter, SIGNAL("textChanged(const QString &)"),
            self.__filterTextChanged)
        
        self.scrollArea = QScrollArea(self.configSplitter)
        self.scrollArea.setFrameShape(QFrame.NoFrame)
        self.scrollArea.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
        self.scrollArea.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
        self.scrollArea.setWidgetResizable(False)
        self.scrollArea.setObjectName("scrollArea")
        
        self.configStack = QStackedWidget()
        self.configStack.setFrameShape(QFrame.Box)
        self.configStack.setFrameShadow(QFrame.Sunken)
        self.configStack.setObjectName("configStack")
        self.scrollArea.setWidget(self.configStack)
        
        self.emptyPage = QWidget()
        self.emptyPage.setGeometry(QRect(0, 0, 372, 591))
        self.emptyPage.setObjectName("emptyPage")
        self.vboxlayout = QVBoxLayout(self.emptyPage)
        self.vboxlayout.setSpacing(6)
        self.vboxlayout.setMargin(6)
        self.vboxlayout.setObjectName("vboxlayout")
        spacerItem = QSpacerItem(20, 20, QSizePolicy.Minimum, QSizePolicy.Expanding)
        self.vboxlayout.addItem(spacerItem)
        self.emptyPagePixmap = QLabel(self.emptyPage)
        self.emptyPagePixmap.setAlignment(Qt.AlignCenter)
        self.emptyPagePixmap.setObjectName("emptyPagePixmap")
        self.emptyPagePixmap.setPixmap(
            QPixmap(os.path.join(getConfig('ericPixDir'), 'eric.png')))
        self.vboxlayout.addWidget(self.emptyPagePixmap)
        self.textLabel1 = QLabel(self.emptyPage)
        self.textLabel1.setAlignment(Qt.AlignCenter)
        self.textLabel1.setObjectName("textLabel1")
        self.vboxlayout.addWidget(self.textLabel1)
        spacerItem1 = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
        self.vboxlayout.addItem(spacerItem1)
        self.configStack.addWidget(self.emptyPage)
        
        self.verticalLayout_2.addWidget(self.configSplitter)
        
        self.buttonBox = QDialogButtonBox(self)
        self.buttonBox.setOrientation(Qt.Horizontal)
        self.buttonBox.setStandardButtons(
            QDialogButtonBox.Apply | QDialogButtonBox.Cancel | \
            QDialogButtonBox.Ok | QDialogButtonBox.Reset)
        self.buttonBox.setObjectName("buttonBox")
        if not self.fromEric and self.displayMode == ConfigurationWidget.DefaultMode:
            self.buttonBox.button(QDialogButtonBox.Apply).hide()
        self.buttonBox.button(QDialogButtonBox.Apply).setEnabled(False)
        self.buttonBox.button(QDialogButtonBox.Reset).setEnabled(False)
        self.verticalLayout_2.addWidget(self.buttonBox)

        self.setWindowTitle(self.trUtf8("Preferences"))
        
        self.configList.header().hide()
        self.configList.header().setSortIndicator(0, Qt.AscendingOrder)
        self.configList.setSortingEnabled(True)
        self.textLabel1.setText(self.trUtf8("Please select an entry of the list \n"
            "to display the configuration page."))
        
        QMetaObject.connectSlotsByName(self)
        self.setTabOrder(self.configList, self.configStack)
        
        self.configStack.setCurrentWidget(self.emptyPage)
        
        self.configList.setFocus()