--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ExtensionCorba/ProjectInterfacesBrowser.py Wed Nov 30 17:56:36 2022 +0100 @@ -0,0 +1,817 @@ +# -*- coding: utf-8 -*- + +# Copyright (c) 2002 - 2022 Detlev Offenbach <detlev@die-offenbachs.de> +# + +""" +Module implementing the a class used to display the interfaces (IDL) part +of the project. +""" + +import contextlib +import glob +import os + +from PyQt6.QtCore import QProcess, QThread, pyqtSignal +from PyQt6.QtWidgets import QApplication, QDialog, QMenu + +from eric7 import Preferences, Utilities +from eric7.EricGui import EricPixmapCache +from eric7.EricWidgets import EricMessageBox +from eric7.EricWidgets.EricApplication import ericApp +from eric7.EricWidgets.EricProgressDialog import EricProgressDialog +from eric7.Project.FileCategoryRepositoryItem import FileCategoryRepositoryItem +from eric7.Project.ProjectBaseBrowser import ProjectBaseBrowser +from eric7.Project.ProjectBrowserModel import ( + ProjectBrowserDirectoryItem, + ProjectBrowserFileItem, + ProjectBrowserSimpleDirectoryItem, +) +from eric7.Project.ProjectBrowserRepositoryItem import ProjectBrowserRepositoryItem +from eric7.UI.BrowserModel import ( + BrowserClassAttributeItem, + BrowserClassItem, + BrowserFileItem, + BrowserMethodItem, +) +from eric7.UI.DeleteFilesConfirmationDialog import DeleteFilesConfirmationDialog +from eric7.UI.NotificationWidget import NotificationTypes + + +class ProjectInterfacesBrowser(ProjectBaseBrowser): + """ + A class used to display the interfaces (IDL) part of the project. + + @signal appendStdout(str) emitted after something was received from + a QProcess on stdout + @signal appendStderr(str) emitted after something was received from + a QProcess on stderr + @signal showMenu(str, QMenu) emitted when a menu is about to be shown. + The name of the menu and a reference to the menu are given. + """ + + appendStdout = pyqtSignal(str) + appendStderr = pyqtSignal(str) + showMenu = pyqtSignal(str, QMenu) + + FileFilter = "idl" + + def __init__(self, plugin, parent=None): + """ + Constructor + + @param plugin reference to the plugin object + @type CorbaExtensionPlugin + @param parent parent widget of this browser + @type QWidget + """ + project = ericApp().getObject("Project") + projectBrowser = ericApp().getObject("ProjectBrowser") + + self.omniidl = plugin.getPreferences("omniidl") + if self.omniidl == "": + self.omniidl = "omniidl.exe" if Utilities.isWindowsPlatform() else "omniidl" + if not Utilities.isinpath(self.omniidl): + self.omniidl = None + + ProjectBaseBrowser.__init__(self, project, self.FileFilter, parent) + + self.selectedItemsFilter = [ + ProjectBrowserFileItem, + ProjectBrowserSimpleDirectoryItem, + ] + + self.setWindowTitle(self.tr("Interfaces")) + + self.setWhatsThis( + self.tr( + """<b>Project IDL Browser</b>""" + """<p>This allows to easily see all CORBA IDL files contained in the""" + """ current project. Several actions can be executed via the context""" + """ menu.</p>""" + ) + ) + + # Add the file category handled by the browser. + project.addFileCategory( + "INTERFACES", + FileCategoryRepositoryItem( + fileCategoryFilterTemplate=self.tr("CORBA IDL Files ({0})"), + fileCategoryUserString=self.tr("CORBA IDL Files"), + fileCategoryTyeString=self.tr("IDL Files"), + fileCategoryExtensions=["*.idl"], + ), + ) + + # Add the project browser type to the browser type repository. + projectBrowser.addTypedProjectBrowser( + "interfaces", + ProjectBrowserRepositoryItem( + projectBrowser=self, + projectBrowserUserString=self.tr("CORBA IDL Browser"), + priority=50, + fileCategory="INTERFACES", + fileFilter=self.FileFilter, + getIcon=self.getIcon, + ), + ) + + # Connect signals of Project. + project.prepareRepopulateItem.connect(self._prepareRepopulateItem) + project.completeRepopulateItem.connect(self._completeRepopulateItem) + project.projectClosed.connect(self._projectClosed) + project.projectOpened.connect(self._projectOpened) + project.newProject.connect(self._newProject) + project.reinitVCS.connect(self._initMenusAndVcs) + project.projectPropertiesChanged.connect(self._initMenusAndVcs) + + # Connect signals of ProjectBrowser. + projectBrowser.preferencesChanged.connect(self.handlePreferencesChanged) + + # Connect some of our own signals. + self.appendStderr.connect(projectBrowser.appendStderr) + self.appendStdout.connect(projectBrowser.appendStdout) + self.closeSourceWindow.connect(projectBrowser.closeSourceWindow) + self.sourceFile[str].connect(projectBrowser.sourceFile[str]) + self.sourceFile[str, int].connect(projectBrowser.sourceFile[str, int]) + + def deactivate(self): + """ + Public method to deactivate the browser. + """ + project = ericApp().getObject("Project") + projectBrowser = ericApp().getObject("ProjectBrowser") + + # Disconnect some of our own signals. + self.appendStderr.disconnect(projectBrowser.appendStderr) + self.appendStdout.disconnect(projectBrowser.appendStdout) + self.closeSourceWindow.disconnect(projectBrowser.closeSourceWindow) + self.sourceFile[str].disconnect(projectBrowser.sourceFile[str]) + self.sourceFile[str, int].disconnect(projectBrowser.sourceFile[str, int]) + + # Disconnect signals of ProjectBrowser. + projectBrowser.preferencesChanged.disconnect(self.handlePreferencesChanged) + + # Disconnect signals of Project. + project.prepareRepopulateItem.disconnect(self._prepareRepopulateItem) + project.completeRepopulateItem.disconnect(self._completeRepopulateItem) + project.projectClosed.disconnect(self._projectClosed) + project.projectOpened.disconnect(self._projectOpened) + project.newProject.disconnect(self._newProject) + project.reinitVCS.disconnect(self._initMenusAndVcs) + project.projectPropertiesChanged.disconnect(self._initMenusAndVcs) + + # Remove the project browser type from the browser type repository. + projectBrowser.removeTypedProjectBrowser("interfaces") + + # Remove the file category handled by the browser. + project.addFileCategory("INTERFACES") + + def getIcon(self): + """ + Public method to get an icon for the project browser. + + @return icon for the browser + @rtype QIcon + """ + iconSuffix = "dark" if ericApp().usesDarkPalette() else "light" + + return EricPixmapCache.getIcon( + os.path.join( + os.path.dirname(__file__), + "icons", + "projectInterfaces-{0}".format(iconSuffix), + ) + ) + + def _createPopupMenus(self): + """ + Protected overloaded method to generate the popup menu. + """ + self.menuActions = [] + self.multiMenuActions = [] + self.dirMenuActions = [] + self.dirMultiMenuActions = [] + + self.sourceMenu = QMenu(self) + if self.omniidl is not None: + self.sourceMenu.addAction( + self.tr("Compile interface"), self.__compileInterface + ) + self.sourceMenu.addAction( + self.tr("Compile all interfaces"), self.__compileAllInterfaces + ) + self.sourceMenu.addSeparator() + self.sourceMenu.addAction( + self.tr("Configure IDL compiler"), self.__configureIdlCompiler + ) + self.sourceMenu.addSeparator() + self.sourceMenu.addAction(self.tr("Open"), self._openItem) + self.sourceMenu.addSeparator() + act = self.sourceMenu.addAction(self.tr("Rename file"), self._renameFile) + self.menuActions.append(act) + act = self.sourceMenu.addAction( + self.tr("Remove from project"), self._removeFile + ) + self.menuActions.append(act) + act = self.sourceMenu.addAction(self.tr("Delete"), self.__deleteFile) + self.menuActions.append(act) + self.sourceMenu.addSeparator() + self.sourceMenu.addAction( + self.tr("Add interfaces..."), self.__addInterfaceFiles + ) + self.sourceMenu.addAction( + self.tr("Add interfaces directory..."), self.__addInterfacesDirectory + ) + self.sourceMenu.addSeparator() + self.sourceMenu.addAction( + self.tr("Copy Path to Clipboard"), self._copyToClipboard + ) + self.sourceMenu.addSeparator() + self.sourceMenu.addAction( + self.tr("Expand all directories"), self._expandAllDirs + ) + self.sourceMenu.addAction( + self.tr("Collapse all directories"), self._collapseAllDirs + ) + self.sourceMenu.addSeparator() + self.sourceMenu.addAction(self.tr("Configure..."), self._configure) + self.sourceMenu.addAction(self.tr("Configure CORBA..."), self.__configureCorba) + + self.menu = QMenu(self) + if self.omniidl is not None: + self.menu.addAction(self.tr("Compile interface"), self.__compileInterface) + self.menu.addAction( + self.tr("Compile all interfaces"), self.__compileAllInterfaces + ) + self.menu.addSeparator() + self.menu.addAction( + self.tr("Configure IDL compiler"), self.__configureIdlCompiler + ) + self.menu.addSeparator() + self.menu.addAction(self.tr("Open"), self._openItem) + self.menu.addSeparator() + self.menu.addAction(self.tr("Add interfaces..."), self.__addInterfaceFiles) + self.menu.addAction( + self.tr("Add interfaces directory..."), self.__addInterfacesDirectory + ) + self.menu.addSeparator() + self.menu.addAction(self.tr("Expand all directories"), self._expandAllDirs) + self.menu.addAction(self.tr("Collapse all directories"), self._collapseAllDirs) + self.menu.addSeparator() + self.menu.addAction(self.tr("Configure..."), self._configure) + self.menu.addAction(self.tr("Configure CORBA..."), self.__configureCorba) + + self.backMenu = QMenu(self) + if self.omniidl is not None: + self.backMenu.addAction( + self.tr("Compile all interfaces"), self.__compileAllInterfaces + ) + self.backMenu.addSeparator() + self.backMenu.addAction( + self.tr("Configure IDL compiler"), self.__configureIdlCompiler + ) + self.backMenu.addSeparator() + self.backMenu.addAction( + self.tr("Add interfaces..."), lambda: self.project.addFiles("INTERFACES") + ) + self.backMenu.addAction( + self.tr("Add interfaces directory..."), + lambda: self.project.addDirectory("INTERFACES"), + ) + self.backMenu.addSeparator() + self.backMenu.addAction(self.tr("Expand all directories"), self._expandAllDirs) + self.backMenu.addAction( + self.tr("Collapse all directories"), self._collapseAllDirs + ) + self.backMenu.addSeparator() + self.backMenu.addAction(self.tr("Configure..."), self._configure) + self.backMenu.addAction(self.tr("Configure CORBA..."), self.__configureCorba) + self.backMenu.setEnabled(False) + + # create the menu for multiple selected files + self.multiMenu = QMenu(self) + if self.omniidl is not None: + self.multiMenu.addAction( + self.tr("Compile interfaces"), self.__compileSelectedInterfaces + ) + self.multiMenu.addSeparator() + self.multiMenu.addAction( + self.tr("Configure IDL compiler"), self.__configureIdlCompiler + ) + self.multiMenu.addSeparator() + self.multiMenu.addAction(self.tr("Open"), self._openItem) + self.multiMenu.addSeparator() + act = self.multiMenu.addAction(self.tr("Remove from project"), self._removeFile) + self.multiMenuActions.append(act) + act = self.multiMenu.addAction(self.tr("Delete"), self.__deleteFile) + self.multiMenuActions.append(act) + self.multiMenu.addSeparator() + self.multiMenu.addAction(self.tr("Expand all directories"), self._expandAllDirs) + self.multiMenu.addAction( + self.tr("Collapse all directories"), self._collapseAllDirs + ) + self.multiMenu.addSeparator() + self.multiMenu.addAction(self.tr("Configure..."), self._configure) + self.multiMenu.addAction(self.tr("Configure CORBA..."), self.__configureCorba) + + self.dirMenu = QMenu(self) + if self.omniidl is not None: + self.dirMenu.addAction( + self.tr("Compile all interfaces"), self.__compileAllInterfaces + ) + self.dirMenu.addSeparator() + self.dirMenu.addAction( + self.tr("Configure IDL compiler"), self.__configureIdlCompiler + ) + self.dirMenu.addSeparator() + act = self.dirMenu.addAction(self.tr("Remove from project"), self._removeFile) + self.dirMenuActions.append(act) + act = self.dirMenu.addAction(self.tr("Delete"), self._deleteDirectory) + self.dirMenuActions.append(act) + self.dirMenu.addSeparator() + self.dirMenu.addAction(self.tr("Add interfaces..."), self.__addInterfaceFiles) + self.dirMenu.addAction( + self.tr("Add interfaces directory..."), self.__addInterfacesDirectory + ) + self.dirMenu.addSeparator() + self.dirMenu.addAction(self.tr("Copy Path to Clipboard"), self._copyToClipboard) + self.dirMenu.addSeparator() + self.dirMenu.addAction(self.tr("Expand all directories"), self._expandAllDirs) + self.dirMenu.addAction( + self.tr("Collapse all directories"), self._collapseAllDirs + ) + self.dirMenu.addSeparator() + self.dirMenu.addAction(self.tr("Configure..."), self._configure) + self.dirMenu.addAction(self.tr("Configure CORBA..."), self.__configureCorba) + + self.dirMultiMenu = QMenu(self) + if self.omniidl is not None: + self.dirMultiMenu.addAction( + self.tr("Compile all interfaces"), self.__compileAllInterfaces + ) + self.dirMultiMenu.addSeparator() + self.dirMultiMenu.addAction( + self.tr("Configure IDL compiler"), self.__configureIdlCompiler + ) + self.dirMultiMenu.addSeparator() + self.dirMultiMenu.addAction( + self.tr("Add interfaces..."), lambda: self.project.addFiles("INTERFACES") + ) + self.dirMultiMenu.addAction( + self.tr("Add interfaces directory..."), + lambda: self.project.addDirectory("INTERFACES"), + ) + self.dirMultiMenu.addSeparator() + self.dirMultiMenu.addAction( + self.tr("Expand all directories"), self._expandAllDirs + ) + self.dirMultiMenu.addAction( + self.tr("Collapse all directories"), self._collapseAllDirs + ) + self.dirMultiMenu.addSeparator() + self.dirMultiMenu.addAction(self.tr("Configure..."), self._configure) + self.dirMultiMenu.addAction( + self.tr("Configure CORBA..."), self.__configureCorba + ) + + self.sourceMenu.aboutToShow.connect(self.__showContextMenu) + self.multiMenu.aboutToShow.connect(self.__showContextMenuMulti) + self.dirMenu.aboutToShow.connect(self.__showContextMenuDir) + self.dirMultiMenu.aboutToShow.connect(self.__showContextMenuDirMulti) + self.backMenu.aboutToShow.connect(self.__showContextMenuBack) + self.mainMenu = self.sourceMenu + + def _contextMenuRequested(self, coord): + """ + Protected slot to show the context menu. + + @param coord the position of the mouse pointer (QPoint) + """ + if not self.project.isOpen(): + return + + with contextlib.suppress(Exception): # secok + categories = self.getSelectedItemsCountCategorized( + [ + ProjectBrowserFileItem, + BrowserClassItem, + BrowserMethodItem, + ProjectBrowserSimpleDirectoryItem, + ] + ) + cnt = categories["sum"] + if cnt <= 1: + index = self.indexAt(coord) + if index.isValid(): + self._selectSingleItem(index) + categories = self.getSelectedItemsCountCategorized( + [ + ProjectBrowserFileItem, + BrowserClassItem, + BrowserMethodItem, + ProjectBrowserSimpleDirectoryItem, + ] + ) + cnt = categories["sum"] + + bfcnt = categories[str(ProjectBrowserFileItem)] + cmcnt = ( + categories[str(BrowserClassItem)] + categories[str(BrowserMethodItem)] + ) + sdcnt = categories[str(ProjectBrowserSimpleDirectoryItem)] + if cnt > 1 and cnt == bfcnt: + self.multiMenu.popup(self.mapToGlobal(coord)) + elif cnt > 1 and cnt == sdcnt: + self.dirMultiMenu.popup(self.mapToGlobal(coord)) + else: + index = self.indexAt(coord) + if cnt == 1 and index.isValid(): + if bfcnt == 1 or cmcnt == 1: + itm = self.model().item(index) + if isinstance(itm, ProjectBrowserFileItem): + self.sourceMenu.popup(self.mapToGlobal(coord)) + elif isinstance(itm, (BrowserClassItem, BrowserMethodItem)): + self.menu.popup(self.mapToGlobal(coord)) + else: + self.backMenu.popup(self.mapToGlobal(coord)) + elif sdcnt == 1: + self.dirMenu.popup(self.mapToGlobal(coord)) + else: + self.backMenu.popup(self.mapToGlobal(coord)) + else: + self.backMenu.popup(self.mapToGlobal(coord)) + + def __showContextMenu(self): + """ + Private slot called by the menu aboutToShow signal. + """ + ProjectBaseBrowser._showContextMenu(self, self.menu) + + self.showMenu.emit("Main", self.menu) + + def __showContextMenuMulti(self): + """ + Private slot called by the multiMenu aboutToShow signal. + """ + ProjectBaseBrowser._showContextMenuMulti(self, self.multiMenu) + + self.showMenu.emit("MainMulti", self.multiMenu) + + def __showContextMenuDir(self): + """ + Private slot called by the dirMenu aboutToShow signal. + """ + ProjectBaseBrowser._showContextMenuDir(self, self.dirMenu) + + self.showMenu.emit("MainDir", self.dirMenu) + + def __showContextMenuDirMulti(self): + """ + Private slot called by the dirMultiMenu aboutToShow signal. + """ + ProjectBaseBrowser._showContextMenuDirMulti(self, self.dirMultiMenu) + + self.showMenu.emit("MainDirMulti", self.dirMultiMenu) + + def __showContextMenuBack(self): + """ + Private slot called by the backMenu aboutToShow signal. + """ + ProjectBaseBrowser._showContextMenuBack(self, self.backMenu) + + self.showMenu.emit("MainBack", self.backMenu) + + def _openItem(self): + """ + Protected slot to handle the open popup menu entry. + """ + itmList = self.getSelectedItems( + [ + BrowserFileItem, + BrowserClassItem, + BrowserMethodItem, + BrowserClassAttributeItem, + ] + ) + + for itm in itmList: + if isinstance(itm, BrowserFileItem): + self.sourceFile[str].emit(itm.fileName()) + elif isinstance(itm, BrowserClassItem): + self.sourceFile[str, int].emit(itm.fileName(), itm.classObject().lineno) + elif isinstance(itm, BrowserMethodItem): + self.sourceFile[str, int].emit( + itm.fileName(), itm.functionObject().lineno + ) + elif isinstance(itm, BrowserClassAttributeItem): + self.sourceFile[str, int].emit( + itm.fileName(), itm.attributeObject().lineno + ) + + def __addInterfaceFiles(self): + """ + Private method to add interface files to the project. + """ + itm = self.model().item(self.currentIndex()) + if isinstance( + itm, (ProjectBrowserFileItem, BrowserClassItem, BrowserMethodItem) + ): + dn = os.path.dirname(itm.fileName()) + elif isinstance( + itm, (ProjectBrowserSimpleDirectoryItem, ProjectBrowserDirectoryItem) + ): + dn = itm.dirName() + else: + dn = None + self.project.addFiles(self.FileFilter, dn) + + def __addInterfacesDirectory(self): + """ + Private method to add interface files of a directory to the project. + """ + itm = self.model().item(self.currentIndex()) + if isinstance( + itm, (ProjectBrowserFileItem, BrowserClassItem, BrowserMethodItem) + ): + dn = os.path.dirname(itm.fileName()) + elif isinstance( + itm, (ProjectBrowserSimpleDirectoryItem, ProjectBrowserDirectoryItem) + ): + dn = itm.dirName() + else: + dn = None + self.project.addDirectory(self.FileFilter, dn) + + def __deleteFile(self): + """ + Private method to delete files from the project. + """ + itmList = self.getSelectedItems() + + files = [] + fullNames = [] + for itm in itmList: + fn2 = itm.fileName() + fullNames.append(fn2) + fn = self.project.getRelativePath(fn2) + files.append(fn) + + dlg = DeleteFilesConfirmationDialog( + self.parent(), + self.tr("Delete interfaces"), + self.tr( + "Do you really want to delete these interfaces from" " the project?" + ), + files, + ) + + if dlg.exec() == QDialog.DialogCode.Accepted: + for fn2, fn in zip(fullNames, files): + self.closeSourceWindow.emit(fn2) + self.project.deleteFile(fn) + + ########################################################################### + ## Methods to handle the various compile commands + ########################################################################### + + def __readStdout(self): + """ + Private slot to handle the readyReadStandardOutput signal of the + omniidl process. + """ + if self.compileProc is None: + return + + ioEncoding = Preferences.getSystem("IOEncoding") + + self.compileProc.setReadChannel(QProcess.ProcessChannel.StandardOutput) + while self.compileProc and self.compileProc.canReadLine(): + s = "omniidl: " + output = str(self.compileProc.readLine(), ioEncoding, "replace") + s += output + self.appendStdout.emit(s) + + def __readStderr(self): + """ + Private slot to handle the readyReadStandardError signal of the + omniidl process. + """ + if self.compileProc is None: + return + + ioEncoding = Preferences.getSystem("IOEncoding") + + self.compileProc.setReadChannel(QProcess.ProcessChannel.StandardError) + while self.compileProc and self.compileProc.canReadLine(): + s = "omniidl: " + error = str(self.compileProc.readLine(), ioEncoding, "replace") + s += error + self.appendStderr.emit(s) + + def __compileIDLDone(self, exitCode, exitStatus): + """ + Private slot to handle the finished signal of the omniidl process. + + @param exitCode exit code of the process (integer) + @param exitStatus exit status of the process (QProcess.ExitStatus) + """ + pixmapSuffix = "dark" if ericApp().usesDarkPalette() else "light" + pixmap = EricPixmapCache.getPixmap( + os.path.join( + os.path.dirname(__file__), + "icons", + "corba48-{0}".format(pixmapSuffix), + ) + ) + + self.compileRunning = False + ui = ericApp().getObject("UserInterface") + if exitStatus == QProcess.ExitStatus.NormalExit and exitCode == 0: + path = os.path.dirname(self.idlFile) + poaList = glob.glob(os.path.join(path, "*__POA")) + npoaList = [f.replace("__POA", "") for f in poaList] + fileList = glob.glob(os.path.join(path, "*_idl.py")) + for directory in poaList + npoaList: + fileList += Utilities.direntries(directory, True, "*.py") + for file in fileList: + self.project.appendFile(file) + ui.showNotification( + pixmap, + self.tr("Interface Compilation"), + self.tr("The compilation of the interface file was successful."), + ) + else: + ui.showNotification( + pixmap, + self.tr("Interface Compilation"), + self.tr("The compilation of the interface file failed."), + kind=NotificationTypes.CRITICAL, + timeout=0, + ) + self.compileProc = None + + def __compileIDL(self, fn, noDialog=False, progress=None): + """ + Private method to compile a .idl file to python. + + @param fn filename of the .idl file to be compiled (string) + @param noDialog flag indicating silent operations (boolean) + @param progress reference to the progress dialog (EricProgressDialog) + @return reference to the compile process (QProcess) + """ + params = self.project.getProjectData(dataKey="IDLPARAMS") + + self.compileProc = QProcess() + args = [] + + args.append("-bpython") + args.append("-I.") + for directory in params["IncludeDirs"]: + args.append( + "-I{0}".format(self.project.getAbsoluteUniversalPath(directory)) + ) + for name in params["DefinedNames"]: + args.append("-D{0}".format(name)) + for name in params["UndefinedNames"]: + args.append("-U{0}".format(name)) + + fn = self.project.getAbsoluteUniversalPath(fn) + self.idlFile = fn + args.append("-C{0}".format(os.path.dirname(fn))) + args.append(fn) + + self.compileProc.finished.connect(self.__compileIDLDone) + self.compileProc.readyReadStandardOutput.connect(self.__readStdout) + self.compileProc.readyReadStandardError.connect(self.__readStderr) + + self.noDialog = noDialog + self.compileProc.start(self.omniidl, args) + procStarted = self.compileProc.waitForStarted(5000) + if procStarted: + self.compileRunning = True + return self.compileProc + else: + self.compileRunning = False + if progress is not None: + progress.cancel() + EricMessageBox.critical( + self, + self.tr("Process Generation Error"), + self.tr( + "<p>Could not start {0}.<br>" + "Ensure that it is in the search path.</p>" + ).format(self.omniidl), + ) + return None + + def __compileInterface(self): + """ + Private method to compile an interface to python. + """ + if self.omniidl is not None: + itm = self.model().item(self.currentIndex()) + fn2 = itm.fileName() + fn = self.project.getRelativePath(fn2) + self.__compileIDL(fn) + + def __compileAllInterfaces(self): + """ + Private method to compile all interfaces to python. + """ + if self.omniidl is not None: + numIDLs = len(self.project.getProjectData(dataKey="INTERFACES")) + progress = EricProgressDialog( + self.tr("Compiling interfaces..."), + self.tr("Abort"), + 0, + numIDLs, + self.tr("%v/%m Interfaces"), + self, + ) + progress.setModal(True) + progress.setMinimumDuration(0) + progress.setWindowTitle(self.tr("Interfaces")) + + for prog, fn in enumerate( + self.project.getProjectData(dataKey="INTERFACES") + ): + progress.setValue(prog) + if progress.wasCanceled(): + break + proc = self.__compileIDL(fn, True, progress) + if proc is not None: + while proc.state() == QProcess.ProcessState.Running: + QThread.msleep(100) + QApplication.processEvents() + else: + break + progress.setValue(numIDLs) + + def __compileSelectedInterfaces(self): + """ + Private method to compile selected interfaces to python. + """ + if self.omniidl is not None: + items = self.getSelectedItems() + + files = [self.project.getRelativePath(itm.fileName()) for itm in items] + numIDLs = len(files) + progress = EricProgressDialog( + self.tr("Compiling interfaces..."), + self.tr("Abort"), + 0, + numIDLs, + self.tr("%v/%m Interfaces"), + self, + ) + progress.setModal(True) + progress.setMinimumDuration(0) + progress.setWindowTitle(self.tr("Interfaces")) + + for prog, fn in enumerate(files): + progress.setValue(prog) + if progress.wasCanceled(): + break + proc = self.__compileIDL(fn, True, progress) + if proc is not None: + while proc.state() == QProcess.ProcessState.Running: + QThread.msleep(100) + QApplication.processEvents() + else: + break + progress.setValue(numIDLs) + + def __configureIdlCompiler(self): + """ + Private method to show a dialog to configure some options for the + IDL compiler. + """ + from .IdlCompilerOptionsDialog import IdlCompilerOptionsDialog + + params = self.project.getProjectData(dataKey="IDLPARAMS") + + dlg = IdlCompilerOptionsDialog( + params["IncludeDirs"][:], + params["DefinedNames"][:], + params["UndefinedNames"][:], + self.project, + self, + ) + if dlg.exec() == QDialog.DialogCode.Accepted: + include, defined, undefined = dlg.getData() + if include != params["IncludeDirs"]: + params["IncludeDirs"] = include[:] + self.project.setDirty(True) + if defined != params["DefinedNames"]: + params["DefinedNames"] = defined[:] + self.project.setDirty(True) + if undefined != params["UndefinedNames"]: + params["UndefinedNames"] = undefined[:] + self.project.setDirty(True) + + def __configureCorba(self): + """ + Private method to open the configuration dialog. + """ + ericApp().getObject("UserInterface").showPreferences("corbaPage")