Mercurial Repositories > eric / file comparison
comparison: eric7/Preferences/ProgramsDialog.py
eric7/Preferences/ProgramsDialog.py
- branch
- eric7
- changeset 8312
- 800c432b34c8
- parent 8259
- 2bbec88047dd
- child 8318
- 962bce857696
equal
deleted
inserted
replaced
| 8311:4e8b98454baa | 8312:800c432b34c8 |
|---|---|
| 1 # -*- coding: utf-8 -*- | |
| 2 | |
| 3 # Copyright (c) 2006 - 2021 Detlev Offenbach <detlev@die-offenbachs.de> | |
| 4 # | |
| 5 | |
| 6 """ | |
| 7 Module implementing the Programs page. | |
| 8 """ | |
| 9 | |
| 10 import os | |
| 11 import re | |
| 12 import sys | |
| 13 | |
| 14 from PyQt5.QtCore import pyqtSlot, Qt, QProcess | |
| 15 from PyQt5.QtWidgets import ( | |
| 16 QApplication, QTreeWidgetItem, QHeaderView, QDialog, QDialogButtonBox | |
| 17 ) | |
| 18 | |
| 19 from E5Gui.E5Application import e5App | |
| 20 from E5Gui.E5OverrideCursor import E5OverrideCursor | |
| 21 | |
| 22 from .Ui_ProgramsDialog import Ui_ProgramsDialog | |
| 23 | |
| 24 import Preferences | |
| 25 import Utilities | |
| 26 | |
| 27 | |
| 28 class ProgramsDialog(QDialog, Ui_ProgramsDialog): | |
| 29 """ | |
| 30 Class implementing the Programs page. | |
| 31 """ | |
| 32 ToolAvailableRole = Qt.ItemDataRole.UserRole + 1 | |
| 33 | |
| 34 def __init__(self, parent=None): | |
| 35 """ | |
| 36 Constructor | |
| 37 | |
| 38 @param parent The parent widget of this dialog. (QWidget) | |
| 39 """ | |
| 40 super().__init__(parent) | |
| 41 self.setupUi(self) | |
| 42 self.setObjectName("ProgramsDialog") | |
| 43 self.setWindowFlags(Qt.WindowType.Window) | |
| 44 | |
| 45 self.__hasSearched = False | |
| 46 | |
| 47 self.programsList.headerItem().setText( | |
| 48 self.programsList.columnCount(), "") | |
| 49 | |
| 50 self.searchButton = self.buttonBox.addButton( | |
| 51 self.tr("Search"), QDialogButtonBox.ButtonRole.ActionRole) | |
| 52 self.searchButton.setToolTip( | |
| 53 self.tr("Press to search for programs")) | |
| 54 | |
| 55 self.showComboBox.addItems([ | |
| 56 self.tr("All Supported Tools"), | |
| 57 self.tr("Available Tools Only"), | |
| 58 self.tr("Unavailable Tools Only"), | |
| 59 ]) | |
| 60 | |
| 61 def show(self): | |
| 62 """ | |
| 63 Public slot to show the dialog. | |
| 64 """ | |
| 65 QDialog.show(self) | |
| 66 if not self.__hasSearched: | |
| 67 self.on_programsSearchButton_clicked() | |
| 68 | |
| 69 def on_buttonBox_clicked(self, button): | |
| 70 """ | |
| 71 Private slot called by a button of the button box clicked. | |
| 72 | |
| 73 @param button button that was clicked (QAbstractButton) | |
| 74 """ | |
| 75 if button == self.searchButton: | |
| 76 self.on_programsSearchButton_clicked() | |
| 77 | |
| 78 @pyqtSlot() | |
| 79 def on_programsSearchButton_clicked(self): | |
| 80 """ | |
| 81 Private slot to search for all supported/required programs. | |
| 82 """ | |
| 83 self.programsList.clear() | |
| 84 header = self.programsList.header() | |
| 85 header.setSortIndicator(0, Qt.SortOrder.AscendingOrder) | |
| 86 header.setSortIndicatorShown(False) | |
| 87 | |
| 88 with E5OverrideCursor(): | |
| 89 # 1. do the Qt programs | |
| 90 # 1a. Translation Converter | |
| 91 exe = ( | |
| 92 Utilities.isWindowsPlatform() and | |
| 93 "{0}.exe".format(Utilities.generateQtToolName("lrelease")) or | |
| 94 Utilities.generateQtToolName("lrelease") | |
| 95 ) | |
| 96 exe = os.path.join(Utilities.getQtBinariesPath(), exe) | |
| 97 version = self.__createProgramEntry( | |
| 98 self.tr("Translation Converter (Qt)"), exe, '-version', | |
| 99 'lrelease', -1) | |
| 100 # 1b. Qt Designer | |
| 101 if Utilities.isWindowsPlatform(): | |
| 102 exe = os.path.join( | |
| 103 Utilities.getQtBinariesPath(), | |
| 104 "{0}.exe".format(Utilities.generateQtToolName("designer"))) | |
| 105 elif Utilities.isMacPlatform(): | |
| 106 exe = Utilities.getQtMacBundle("designer") | |
| 107 else: | |
| 108 exe = os.path.join( | |
| 109 Utilities.getQtBinariesPath(), | |
| 110 Utilities.generateQtToolName("designer")) | |
| 111 self.__createProgramEntry( | |
| 112 self.tr("Qt Designer"), exe, version=version) | |
| 113 # 1c. Qt Linguist | |
| 114 if Utilities.isWindowsPlatform(): | |
| 115 exe = os.path.join( | |
| 116 Utilities.getQtBinariesPath(), | |
| 117 "{0}.exe".format(Utilities.generateQtToolName("linguist"))) | |
| 118 elif Utilities.isMacPlatform(): | |
| 119 exe = Utilities.getQtMacBundle("linguist") | |
| 120 else: | |
| 121 exe = os.path.join( | |
| 122 Utilities.getQtBinariesPath(), | |
| 123 Utilities.generateQtToolName("linguist")) | |
| 124 self.__createProgramEntry( | |
| 125 self.tr("Qt Linguist"), exe, version=version) | |
| 126 # 1d. Qt Assistant | |
| 127 if Utilities.isWindowsPlatform(): | |
| 128 exe = os.path.join( | |
| 129 Utilities.getQtBinariesPath(), | |
| 130 "{0}.exe".format( | |
| 131 Utilities.generateQtToolName("assistant"))) | |
| 132 elif Utilities.isMacPlatform(): | |
| 133 exe = Utilities.getQtMacBundle("assistant") | |
| 134 else: | |
| 135 exe = os.path.join( | |
| 136 Utilities.getQtBinariesPath(), | |
| 137 Utilities.generateQtToolName("assistant")) | |
| 138 self.__createProgramEntry( | |
| 139 self.tr("Qt Assistant"), exe, version=version) | |
| 140 | |
| 141 # 2. do the PyQt programs | |
| 142 # 2.1 do the PyQt5 programs | |
| 143 # 2.1a. Translation Extractor PyQt5 | |
| 144 self.__createProgramEntry( | |
| 145 self.tr("Translation Extractor (Python, PyQt5)"), | |
| 146 Utilities.generatePyQtToolPath("pylupdate5"), | |
| 147 '-version', 'pylupdate', -1) | |
| 148 # 2.1b. Forms Compiler PyQt5 | |
| 149 self.__createProgramEntry( | |
| 150 self.tr("Forms Compiler (Python, PyQt5)"), | |
| 151 Utilities.generatePyQtToolPath("pyuic5", ["py3uic5"]), | |
| 152 '--version', 'Python User', 4) | |
| 153 # 2.1c. Resource Compiler PyQt5 | |
| 154 self.__createProgramEntry( | |
| 155 self.tr("Resource Compiler (Python, PyQt5)"), | |
| 156 Utilities.generatePyQtToolPath("pyrcc5"), | |
| 157 '-version', '', -1, versionRe='Resource Compiler|pyrcc5') | |
| 158 | |
| 159 # 2.2 do the PyQt6 programs | |
| 160 # 2.2a. Translation Extractor PyQt6 | |
| 161 self.__createProgramEntry( | |
| 162 self.tr("Translation Extractor (Python, PyQt6)"), | |
| 163 Utilities.generatePyQtToolPath("pylupdate6"), | |
| 164 '--version', versionPosition=0) | |
| 165 # 2.2b. Forms Compiler PyQt6 | |
| 166 self.__createProgramEntry( | |
| 167 self.tr("Forms Compiler (Python, PyQt6)"), | |
| 168 Utilities.generatePyQtToolPath("pyuic6"), | |
| 169 '--version', versionPosition=0) | |
| 170 | |
| 171 # 3. do the PySide programs | |
| 172 # 3.1 do the PySide2 programs | |
| 173 # 3.1a. Translation Extractor PySide2 | |
| 174 self.__createProgramEntry( | |
| 175 self.tr("Translation Extractor (Python, PySide2)"), | |
| 176 Utilities.generatePySideToolPath("pyside2-lupdate", variant=2), | |
| 177 '-version', '', -1, versionRe='lupdate') | |
| 178 # 3.1b. Forms Compiler PySide2 | |
| 179 self.__createProgramEntry( | |
| 180 self.tr("Forms Compiler (Python, PySide2)"), | |
| 181 Utilities.generatePySideToolPath("pyside2-uic", variant=2), | |
| 182 '--version', '', -1, versionRe='uic') | |
| 183 # 3.1c Resource Compiler PySide2 | |
| 184 self.__createProgramEntry( | |
| 185 self.tr("Resource Compiler (Python, PySide2)"), | |
| 186 Utilities.generatePySideToolPath("pyside2-rcc", variant=2), | |
| 187 '-version', '', -1, versionRe='rcc') | |
| 188 # 3.2 do the PySide5 programs | |
| 189 # 3.2a. Translation Extractor PySide6 | |
| 190 self.__createProgramEntry( | |
| 191 self.tr("Translation Extractor (Python, PySide6)"), | |
| 192 Utilities.generatePySideToolPath("pyside6-lupdate", variant=6), | |
| 193 '-version', '', -1, versionRe='lupdate') | |
| 194 # 3.2b. Forms Compiler PySide6 | |
| 195 self.__createProgramEntry( | |
| 196 self.tr("Forms Compiler (Python, PySide6)"), | |
| 197 Utilities.generatePySideToolPath("pyside6-uic", variant=6), | |
| 198 '--version', '', -1, versionRe='uic') | |
| 199 # 3.2c Resource Compiler PySide6 | |
| 200 self.__createProgramEntry( | |
| 201 self.tr("Resource Compiler (Python, PySide6)"), | |
| 202 Utilities.generatePySideToolPath("pyside6-rcc", variant=6), | |
| 203 '--version', '', -1, versionRe='rcc') | |
| 204 | |
| 205 # 4. do the Conda program(s) | |
| 206 exe = Preferences.getConda("CondaExecutable") | |
| 207 if not exe: | |
| 208 exe = "conda" | |
| 209 if Utilities.isWindowsPlatform(): | |
| 210 exe += ".exe" | |
| 211 self.__createProgramEntry( | |
| 212 self.tr("conda Manager"), exe, '--version', 'conda', -1) | |
| 213 | |
| 214 # 5. do the pip program(s) | |
| 215 virtualenvManager = e5App().getObject("VirtualEnvManager") | |
| 216 for venvName in virtualenvManager.getVirtualenvNames(): | |
| 217 interpreter = virtualenvManager.getVirtualenvInterpreter( | |
| 218 venvName) | |
| 219 self.__createProgramEntry( | |
| 220 self.tr("PyPI Package Management"), interpreter, | |
| 221 '--version', 'pip', 1, exeModule=["-m", "pip"]) | |
| 222 | |
| 223 # 6. do the CORBA and Protobuf programs | |
| 224 # 6a. omniORB | |
| 225 exe = Preferences.getCorba("omniidl") | |
| 226 if not exe: | |
| 227 exe = "omniidl" | |
| 228 if Utilities.isWindowsPlatform(): | |
| 229 exe += ".exe" | |
| 230 self.__createProgramEntry( | |
| 231 self.tr("CORBA IDL Compiler"), exe, '-V', 'omniidl', -1) | |
| 232 # 6b. protobuf | |
| 233 exe = Preferences.getProtobuf("protoc") | |
| 234 if not exe: | |
| 235 exe = "protoc" | |
| 236 if Utilities.isWindowsPlatform(): | |
| 237 exe += ".exe" | |
| 238 self.__createProgramEntry( | |
| 239 self.tr("Protobuf Compiler"), exe, '--version', 'libprotoc', | |
| 240 -1) | |
| 241 # 6c. grpc | |
| 242 exe = Preferences.getProtobuf("grpcPython") | |
| 243 if not exe: | |
| 244 exe = sys.executable | |
| 245 self.__createProgramEntry( | |
| 246 self.tr("gRPC Compiler"), exe, '--version', 'libprotoc', -1, | |
| 247 exeModule=['-m', 'grpc_tools.protoc']) | |
| 248 | |
| 249 # 7. do the spell checking entry | |
| 250 try: | |
| 251 import enchant | |
| 252 try: | |
| 253 text = os.path.dirname(enchant.__file__) | |
| 254 except AttributeError: | |
| 255 text = "enchant" | |
| 256 try: | |
| 257 version = enchant.__version__ | |
| 258 except AttributeError: | |
| 259 version = self.tr("(unknown)") | |
| 260 except (ImportError, AttributeError, OSError): | |
| 261 text = "enchant" | |
| 262 version = "" | |
| 263 self.__createEntry( | |
| 264 self.tr("Spell Checker - PyEnchant"), text, version) | |
| 265 | |
| 266 # 8. do the pygments entry | |
| 267 try: | |
| 268 import pygments | |
| 269 try: | |
| 270 text = os.path.dirname(pygments.__file__) | |
| 271 except AttributeError: | |
| 272 text = "pygments" | |
| 273 try: | |
| 274 version = pygments.__version__ | |
| 275 except AttributeError: | |
| 276 version = self.tr("(unknown)") | |
| 277 except (ImportError, AttributeError, OSError): | |
| 278 text = "pygments" | |
| 279 version = "" | |
| 280 self.__createEntry( | |
| 281 self.tr("Source Highlighter - Pygments"), text, version) | |
| 282 | |
| 283 # 9. do the MicroPython related entries | |
| 284 exe = Preferences.getMicroPython("MpyCrossCompiler") | |
| 285 if not exe: | |
| 286 exe = "mpy-cross" | |
| 287 self.__createProgramEntry( | |
| 288 self.tr("MicroPython - MPY Cross Compiler"), exe, '--version', | |
| 289 'MicroPython', 1) | |
| 290 self.__createProgramEntry( | |
| 291 self.tr("MicroPython - ESP Tool"), sys.executable, 'version', | |
| 292 'esptool', -1, exeModule=['-m', 'esptool']) | |
| 293 exe = Preferences.getMicroPython("DfuUtilPath") | |
| 294 if not exe: | |
| 295 exe = "dfu-util" | |
| 296 self.__createProgramEntry( | |
| 297 self.tr("MicroPython - PyBoard Flasher"), exe, '--version', | |
| 298 'dfu-util', -1) | |
| 299 | |
| 300 # 10. do the plugin related programs | |
| 301 pm = e5App().getObject("PluginManager") | |
| 302 for info in pm.getPluginExeDisplayData(): | |
| 303 if info["programEntry"]: | |
| 304 if "exeModule" not in info: | |
| 305 info["exeModule"] = None | |
| 306 if "versionRe" not in info: | |
| 307 info["versionRe"] = None | |
| 308 self.__createProgramEntry( | |
| 309 info["header"], | |
| 310 info["exe"], | |
| 311 versionCommand=info["versionCommand"], | |
| 312 versionStartsWith=info["versionStartsWith"], | |
| 313 versionPosition=info["versionPosition"], | |
| 314 version=info["version"], | |
| 315 versionCleanup=info["versionCleanup"], | |
| 316 versionRe=info["versionRe"], | |
| 317 exeModule=info["exeModule"], | |
| 318 ) | |
| 319 else: | |
| 320 self.__createEntry( | |
| 321 info["header"], | |
| 322 info["text"], | |
| 323 info["version"] | |
| 324 ) | |
| 325 | |
| 326 self.programsList.sortByColumn(0, Qt.SortOrder.AscendingOrder) | |
| 327 self.on_showComboBox_currentIndexChanged( | |
| 328 self.showComboBox.currentIndex()) | |
| 329 | |
| 330 self.__hasSearched = True | |
| 331 | |
| 332 def __createProgramEntry(self, description, exe, | |
| 333 versionCommand="", versionStartsWith="", | |
| 334 versionPosition=None, version="", | |
| 335 versionCleanup=None, versionRe=None, | |
| 336 exeModule=None): | |
| 337 """ | |
| 338 Private method to generate a program entry. | |
| 339 | |
| 340 @param description descriptive text (string) | |
| 341 @param exe name of the executable program (string) | |
| 342 @param versionCommand command line switch to get the version info | |
| 343 (str). If this is empty, the given version will be shown. | |
| 344 @param versionStartsWith start of line identifying version info | |
| 345 (string) | |
| 346 @param versionPosition index of part containing the version info | |
| 347 (integer) | |
| 348 @param version version string to show (string) | |
| 349 @param versionCleanup tuple of two integers giving string positions | |
| 350 start and stop for the version string (tuple of integers) | |
| 351 @param versionRe regexp to determine the line identifying version | |
| 352 info (string). Takes precedence over versionStartsWith. | |
| 353 @param exeModule list of command line parameters to execute a module | |
| 354 with the program given in exe (e.g. to execute a Python module) | |
| 355 (list of str) | |
| 356 @return version string of detected or given version (string) | |
| 357 """ | |
| 358 itmList = self.programsList.findItems( | |
| 359 description, Qt.MatchFlag.MatchCaseSensitive) | |
| 360 itm = ( | |
| 361 itmList[0] | |
| 362 if itmList else | |
| 363 QTreeWidgetItem(self.programsList, [description]) | |
| 364 ) | |
| 365 font = itm.font(0) | |
| 366 font.setBold(True) | |
| 367 itm.setFont(0, font) | |
| 368 rememberedExe = exe | |
| 369 if not exe: | |
| 370 itm.setText(1, self.tr("(not configured)")) | |
| 371 else: | |
| 372 if os.path.isabs(exe): | |
| 373 if not Utilities.isExecutable(exe): | |
| 374 exe = "" | |
| 375 else: | |
| 376 exe = Utilities.getExecutablePath(exe) | |
| 377 if exe: | |
| 378 available = True | |
| 379 if versionCommand and versionPosition is not None: | |
| 380 proc = QProcess() | |
| 381 proc.setProcessChannelMode( | |
| 382 QProcess.ProcessChannelMode.MergedChannels) | |
| 383 if exeModule: | |
| 384 args = exeModule[:] + [versionCommand] | |
| 385 else: | |
| 386 args = [versionCommand] | |
| 387 proc.start(exe, args) | |
| 388 finished = proc.waitForFinished(10000) | |
| 389 if finished: | |
| 390 output = str(proc.readAllStandardOutput(), | |
| 391 Preferences.getSystem("IOEncoding"), | |
| 392 'replace') | |
| 393 if ( | |
| 394 exeModule and | |
| 395 exeModule[0] == "-m" and | |
| 396 ("ImportError:" in output or | |
| 397 "ModuleNotFoundError:" in output or | |
| 398 proc.exitCode() != 0) | |
| 399 ): | |
| 400 version = self.tr("(module not found)") | |
| 401 available = False | |
| 402 elif not versionStartsWith and not versionRe: | |
| 403 # assume output is just one line | |
| 404 try: | |
| 405 version = ( | |
| 406 output.strip().split()[versionPosition] | |
| 407 ) | |
| 408 if versionCleanup: | |
| 409 version = version[ | |
| 410 versionCleanup[0]: | |
| 411 versionCleanup[1] | |
| 412 ] | |
| 413 except IndexError: | |
| 414 version = self.tr("(unknown)") | |
| 415 available = False | |
| 416 else: | |
| 417 if versionRe is None: | |
| 418 versionRe = "^{0}".format( | |
| 419 re.escape(versionStartsWith)) | |
| 420 versionRe = re.compile(versionRe, re.UNICODE) | |
| 421 for line in output.splitlines(): | |
| 422 if versionRe.search(line): | |
| 423 try: | |
| 424 version = line.split()[versionPosition] | |
| 425 if versionCleanup: | |
| 426 version = version[ | |
| 427 versionCleanup[0]: | |
| 428 versionCleanup[1] | |
| 429 ] | |
| 430 break | |
| 431 except IndexError: | |
| 432 version = self.tr("(unknown)") | |
| 433 available = False | |
| 434 else: | |
| 435 version = self.tr("(unknown)") | |
| 436 available = False | |
| 437 else: | |
| 438 version = self.tr("(not executable)") | |
| 439 available = False | |
| 440 if exeModule: | |
| 441 citm = QTreeWidgetItem(itm, [ | |
| 442 "{0} {1}".format(exe, " ".join(exeModule)), | |
| 443 version]) | |
| 444 else: | |
| 445 citm = QTreeWidgetItem(itm, [exe, version]) | |
| 446 citm.setData(0, self.ToolAvailableRole, available) | |
| 447 itm.setExpanded(True) | |
| 448 else: | |
| 449 if itm.childCount() == 0: | |
| 450 itm.setText(1, self.tr("(not found)")) | |
| 451 else: | |
| 452 citm = QTreeWidgetItem( | |
| 453 itm, [rememberedExe, self.tr("(not found)")]) | |
| 454 citm.setData(0, self.ToolAvailableRole, False) | |
| 455 itm.setExpanded(True) | |
| 456 QApplication.processEvents() | |
| 457 self.programsList.header().resizeSections( | |
| 458 QHeaderView.ResizeMode.ResizeToContents) | |
| 459 self.programsList.header().setStretchLastSection(True) | |
| 460 return version | |
| 461 | |
| 462 def __createEntry(self, description, entryText, entryVersion): | |
| 463 """ | |
| 464 Private method to generate a program entry. | |
| 465 | |
| 466 @param description descriptive text (string) | |
| 467 @param entryText text to show (string) | |
| 468 @param entryVersion version string to show (string). | |
| 469 """ | |
| 470 itm = QTreeWidgetItem(self.programsList, [description]) | |
| 471 font = itm.font(0) | |
| 472 font.setBold(True) | |
| 473 itm.setFont(0, font) | |
| 474 | |
| 475 if len(entryVersion): | |
| 476 citm = QTreeWidgetItem(itm, [entryText, entryVersion]) | |
| 477 itm.setExpanded(True) | |
| 478 citm.setData(0, self.ToolAvailableRole, | |
| 479 not entryVersion.startswith("(")) | |
| 480 # assume version starting with '(' is an unavailability | |
| 481 else: | |
| 482 itm.setText(1, self.tr("(not found)")) | |
| 483 QApplication.processEvents() | |
| 484 self.programsList.header().resizeSections( | |
| 485 QHeaderView.ResizeMode.ResizeToContents) | |
| 486 self.programsList.header().setStretchLastSection(True) | |
| 487 | |
| 488 @pyqtSlot(int) | |
| 489 def on_showComboBox_currentIndexChanged(self, index): | |
| 490 """ | |
| 491 Private slot to apply the selected show criteria. | |
| 492 | |
| 493 @param index index of the show criterium | |
| 494 @type int | |
| 495 """ | |
| 496 if index == 0: | |
| 497 # All Supported Tools | |
| 498 for topIndex in range(self.programsList.topLevelItemCount()): | |
| 499 topItem = self.programsList.topLevelItem(topIndex) | |
| 500 for childIndex in range(topItem.childCount()): | |
| 501 topItem.child(childIndex).setHidden(False) | |
| 502 topItem.setHidden(False) | |
| 503 else: | |
| 504 # 1 = Available Tools Only | |
| 505 # 2 = Unavailable Tools Only | |
| 506 for topIndex in range(self.programsList.topLevelItemCount()): | |
| 507 topItem = self.programsList.topLevelItem(topIndex) | |
| 508 if topItem.childCount() == 0: | |
| 509 topItem.setHidden(index == 1) | |
| 510 else: | |
| 511 availabilityList = [] | |
| 512 for childIndex in range(topItem.childCount()): | |
| 513 childItem = topItem.child(childIndex) | |
| 514 available = childItem.data(0, self.ToolAvailableRole) | |
| 515 if index == 1: | |
| 516 childItem.setHidden(not available) | |
| 517 else: | |
| 518 childItem.setHidden(available) | |
| 519 availabilityList.append(available) | |
| 520 if index == 1: | |
| 521 topItem.setHidden(not any(availabilityList)) | |
| 522 else: | |
| 523 topItem.setHidden(all(availabilityList)) |
