eric: comparison eric7/HexEdit/HexEditMainWindow.py

-:8a7677a63c8d
+:68ec9c3d4de5
 from PyQt6.QtGui import QKeySequence, QAction
 from PyQt6.QtWidgets import (
 QWhatsThis, QLabel, QWidget, QVBoxLayout, QDialog, QFrame, QMenu
 )
-from E5Gui.E5Action import E5Action
+from E5Gui.EricAction import EricAction
-from E5Gui.E5MainWindow import E5MainWindow
+from E5Gui.EricMainWindow import EricMainWindow
-from E5Gui import E5FileDialog, E5MessageBox
+from E5Gui import EricFileDialog, EricMessageBox
-from E5Gui.E5ClickableLabel import E5ClickableLabel
+from E5Gui.EricClickableLabel import EricClickableLabel
 from Globals import strGroup, recentNameHexFiles
 from .HexEditWidget import HexEditWidget
 from .HexEditSearchReplaceWidget import HexEditSearchReplaceWidget
 import Preferences
 import Utilities
-class HexEditMainWindow(E5MainWindow):
+class HexEditMainWindow(EricMainWindow):
 """
 Class implementing the web browser main window.
 @signal editorClosed() emitted after the window was requested to close down
 """
 def __initFileActions(self):
 """
 Private method to define the file related user interface actions.
 """
-self.newWindowAct = E5Action(
+self.newWindowAct = EricAction(
 self.tr('New Window'),
 UI.PixmapCache.getIcon("newWindow"),
 self.tr('New &Window'),
 0, 0, self, 'hexEditor_file_new_window')
 self.newWindowAct.setStatusTip(self.tr(
 ))
 self.newWindowAct.triggered.connect(self.__openHexFileNewWindow)
 self.__actions.append(self.newWindowAct)
 # correct texts will be set later
-self.openAct = E5Action(
+self.openAct = EricAction(
 self.tr('Open'),
 UI.PixmapCache.getIcon("open"),
 self.tr('&Open...'),
 QKeySequence(self.tr("Ctrl+O", "File|Open")),
 0, self, 'hexEditor_file_open')
 self.openAct.triggered.connect(self.__openHexFile)
 self.__actions.append(self.openAct)
 # correct texts will be set later
-self.openReadOnlyAct = E5Action(
+self.openReadOnlyAct = EricAction(
 "", "",
 0, 0, self, 'hexEditor_file_open_read_only')
 self.openReadOnlyAct.triggered.connect(self.__openHexFileReadOnly)
 self.__actions.append(self.openReadOnlyAct)
-self.saveAct = E5Action(
+self.saveAct = EricAction(
 self.tr('Save'),
 UI.PixmapCache.getIcon("fileSave"),
 self.tr('&Save'),
 QKeySequence(self.tr("Ctrl+S", "File|Save")),
 0, self, 'hexEditor_file_save')
 """<p>Save the contents of the hex editor window.</p>"""
 ))
 self.saveAct.triggered.connect(self.__saveHexFile)
 self.__actions.append(self.saveAct)
-self.saveAsAct = E5Action(
+self.saveAsAct = EricAction(
 self.tr('Save As'),
 UI.PixmapCache.getIcon("fileSaveAs"),
 self.tr('Save &As...'),
 QKeySequence(self.tr("Shift+Ctrl+S", "File|Save As")),
 0, self, 'hexEditor_file_save_as')
 """<p>Saves the current binary data to a new file.</p>"""
 ))
 self.saveAsAct.triggered.connect(self.__saveHexFileAs)
 self.__actions.append(self.saveAsAct)
-self.saveReadableAct = E5Action(
+self.saveReadableAct = EricAction(
 self.tr('Save As Readable'),
 self.tr('Save As &Readable...'),
 0, 0, self, 'hexEditor_file_save_readable')
 self.saveReadableAct.setStatusTip(
 self.tr('Save the current binary data to a new file in a readable'
 """ format.</p>"""
 ))
 self.saveReadableAct.triggered.connect(self.__saveHexFileReadable)
 self.__actions.append(self.saveReadableAct)
-self.closeAct = E5Action(
+self.closeAct = EricAction(
 self.tr('Close'),
 UI.PixmapCache.getIcon("close"),
 self.tr('&Close'),
 QKeySequence(self.tr("Ctrl+W", "File|Close")),
 0, self, 'hexEditor_file_close')
 """<p>Closes the current hex editor window.</p>"""
 ))
 self.closeAct.triggered.connect(self.close)
 self.__actions.append(self.closeAct)
-self.closeAllAct = E5Action(
+self.closeAllAct = EricAction(
 self.tr('Close All'),
 self.tr('Close &All'),
 0, 0, self, 'hexEditor_file_close_all')
 self.closeAllAct.setStatusTip(self.tr(
 'Close all hex editor windows'))
 """<p>Closes all hex editor windows.</p>"""
 ))
 self.closeAllAct.triggered.connect(self.__closeAll)
 self.__actions.append(self.closeAllAct)
-self.closeOthersAct = E5Action(
+self.closeOthersAct = EricAction(
 self.tr('Close Others'),
 self.tr('Close Others'),
 0, 0, self, 'hexEditor_file_close_others')
 self.closeOthersAct.setStatusTip(self.tr(
 'Close all other hex editor windows'))
 """<p>Closes all other hex editor windows.</p>"""
 ))
 self.closeOthersAct.triggered.connect(self.__closeOthers)
 self.__actions.append(self.closeOthersAct)
-self.exitAct = E5Action(
+self.exitAct = EricAction(
 self.tr('Quit'),
 UI.PixmapCache.getIcon("exit"),
 self.tr('&Quit'),
 QKeySequence(self.tr("Ctrl+Q", "File|Quit")),
 0, self, 'hexEditor_file_quit')
 def __initEditActions(self):
 """
 Private method to create the Edit actions.
 """
-self.undoAct = E5Action(
+self.undoAct = EricAction(
 self.tr('Undo'),
 UI.PixmapCache.getIcon("editUndo"),
 self.tr('&Undo'),
 QKeySequence(self.tr("Ctrl+Z", "Edit|Undo")),
 QKeySequence(self.tr("Alt+Backspace", "Edit|Undo")),
 """<p>Undo the last change done.</p>"""
 ))
 self.undoAct.triggered.connect(self.__editor.undo)
 self.__actions.append(self.undoAct)
-self.redoAct = E5Action(
+self.redoAct = EricAction(
 self.tr('Redo'),
 UI.PixmapCache.getIcon("editRedo"),
 self.tr('&Redo'),
 QKeySequence(self.tr("Ctrl+Shift+Z", "Edit|Redo")),
 0, self, 'hexEditor_edit_redo')
 """<p>Redo the last change done.</p>"""
 ))
 self.redoAct.triggered.connect(self.__editor.redo)
 self.__actions.append(self.redoAct)
-self.revertAct = E5Action(
+self.revertAct = EricAction(
 self.tr('Revert to last saved state'),
 self.tr('Re&vert to last saved state'),
 QKeySequence(self.tr("Ctrl+Y", "Edit|Revert")),
 0,
 self, 'hexEditor_edit_revert')
 """ editor.</p>"""
 ))
 self.revertAct.triggered.connect(self.__editor.revertToUnmodified)
 self.__actions.append(self.revertAct)
-self.cutAct = E5Action(
+self.cutAct = EricAction(
 self.tr('Cut'),
 UI.PixmapCache.getIcon("editCut"),
 self.tr('Cu&t'),
 QKeySequence(self.tr("Ctrl+X", "Edit|Cut")),
 QKeySequence(self.tr("Shift+Del", "Edit|Cut")),
 """<p>Cut the selected binary area to the clipboard.</p>"""
 ))
 self.cutAct.triggered.connect(self.__editor.cut)
 self.__actions.append(self.cutAct)
-self.copyAct = E5Action(
+self.copyAct = EricAction(
 self.tr('Copy'),
 UI.PixmapCache.getIcon("editCopy"),
 self.tr('&Copy'),
 QKeySequence(self.tr("Ctrl+C", "Edit|Copy")),
 QKeySequence(self.tr("Ctrl+Ins", "Edit|Copy")),
 """<p>Copy the selected binary area to the clipboard.</p>"""
 ))
 self.copyAct.triggered.connect(self.__editor.copy)
 self.__actions.append(self.copyAct)
-self.pasteAct = E5Action(
+self.pasteAct = EricAction(
 self.tr('Paste'),
 UI.PixmapCache.getIcon("editPaste"),
 self.tr('&Paste'),
 QKeySequence(self.tr("Ctrl+V", "Edit|Paste")),
 QKeySequence(self.tr("Shift+Ins", "Edit|Paste")),
 """<p>Paste the clipboard contents.</p>"""
 ))
 self.pasteAct.triggered.connect(self.__editor.paste)
 self.__actions.append(self.pasteAct)
-self.selectAllAct = E5Action(
+self.selectAllAct = EricAction(
 self.tr('Select All'),
 UI.PixmapCache.getIcon("editSelectAll"),
 self.tr('&Select All'),
 QKeySequence(self.tr("Ctrl+A", "Edit|Select All")),
 0,
 """<p>Selects the complete binary data.</p>"""
 ))
 self.selectAllAct.triggered.connect(self.__editor.selectAll)
 self.__actions.append(self.selectAllAct)
-self.deselectAllAct = E5Action(
+self.deselectAllAct = EricAction(
 self.tr('Deselect all'),
 self.tr('&Deselect all'),
 QKeySequence(self.tr("Alt+Ctrl+A", "Edit|Deselect all")),
 0,
 self, 'hexEditor_edit_deselect_all')
 """<p>Deselect all all binary data.</p>"""
 ))
 self.deselectAllAct.triggered.connect(self.__editor.deselectAll)
 self.__actions.append(self.deselectAllAct)
-self.saveSelectionReadableAct = E5Action(
+self.saveSelectionReadableAct = EricAction(
 self.tr('Save Selection Readable'),
 self.tr('Save Selection Readable...'),
 0, 0, self, 'hexEditor_edit_selection_save_readable')
 self.saveSelectionReadableAct.setStatusTip(
 self.tr('Save the binary data of the current selection to a file'
 ))
 self.saveSelectionReadableAct.triggered.connect(
 self.__saveSelectionReadable)
 self.__actions.append(self.saveSelectionReadableAct)
-self.readonlyAct = E5Action(
+self.readonlyAct = EricAction(
 self.tr('Set Read Only'),
 self.tr('Set Read Only'),
 0, 0, self, 'hexEditor_edit_readonly', True)
 self.readonlyAct.setStatusTip(self.tr(
 'Change the edit mode to read only'))
 self.readonlyAct.setChecked(False)
 self.readonlyAct.toggled[bool].connect(self.__editor.setReadOnly)
 self.__editor.readOnlyChanged.connect(self.readonlyAct.setChecked)
 self.__actions.append(self.readonlyAct)
-self.searchAct = E5Action(
+self.searchAct = EricAction(
 self.tr('Search'),
 UI.PixmapCache.getIcon("find"),
 self.tr('&Search...'),
 QKeySequence(self.tr("Ctrl+F", "Search|Search")),
 0,
 """ data to search for in various formats.</p>"""
 ))
 self.searchAct.triggered.connect(self.__search)
 self.__actions.append(self.searchAct)
-self.searchNextAct = E5Action(
+self.searchNextAct = EricAction(
 self.tr('Search next'),
 UI.PixmapCache.getIcon("findNext"),
 self.tr('Search &next'),
 QKeySequence(self.tr("F3", "Search|Search next")),
 0,
 """ entered search data are reused.</p>"""
 ))
 self.searchNextAct.triggered.connect(self.__searchWidget.findPrevNext)
 self.__actions.append(self.searchNextAct)
-self.searchPrevAct = E5Action(
+self.searchPrevAct = EricAction(
 self.tr('Search previous'),
 UI.PixmapCache.getIcon("findPrev"),
 self.tr('Search &previous'),
 QKeySequence(self.tr("Shift+F3", "Search|Search previous")),
 0,
 ))
 self.searchPrevAct.triggered.connect(
 lambda: self.__searchWidget.findPrevNext(True))
 self.__actions.append(self.searchPrevAct)
-self.replaceAct = E5Action(
+self.replaceAct = EricAction(
 self.tr('Replace'),
 self.tr('&Replace...'),
 QKeySequence(self.tr("Ctrl+R", "Search|Replace")),
 0,
 self, 'hexEditor_edit_search_replace')
 """ replacement data in various formats.</p>"""
 ))
 self.replaceAct.triggered.connect(self.__replace)
 self.__actions.append(self.replaceAct)
-self.gotoAct = E5Action(
+self.gotoAct = EricAction(
 self.tr('Goto Offset'),
 UI.PixmapCache.getIcon("goto"),
 self.tr('&Goto Offset...'),
 QKeySequence(QCoreApplication.translate(
 'ViewManager', "Ctrl+G", "Search|Goto Offset")),
 def __initHelpActions(self):
 """
 Private method to create the Help actions.
 """
-self.aboutAct = E5Action(
+self.aboutAct = EricAction(
 self.tr('About'),
 self.tr('&About'),
 0, 0, self, 'hexEditor_help_about')
 self.aboutAct.setStatusTip(self.tr(
 'Display information about this software'))
 """<b>About</b>"""
 """<p>Display some information about this software.</p>"""))
 self.aboutAct.triggered.connect(self.__about)
 self.__actions.append(self.aboutAct)
-self.aboutQtAct = E5Action(
+self.aboutQtAct = EricAction(
 self.tr('About Qt'),
 self.tr('About &Qt'),
 0, 0, self, 'hexEditor_help_about_qt')
 self.aboutQtAct.setStatusTip(
 self.tr('Display information about the Qt toolkit'))
 """<p>Display some information about the Qt toolkit.</p>"""
 ))
 self.aboutQtAct.triggered.connect(self.__aboutQt)
 self.__actions.append(self.aboutQtAct)
-self.whatsThisAct = E5Action(
+self.whatsThisAct = EricAction(
 self.tr('What\'s This?'),
 UI.PixmapCache.getIcon("whatsThis"),
 self.tr('&What\'s This?'),
 QKeySequence(self.tr("Shift+F1", "Help|What's This?'")),
 0, self, 'hexEditor_help_whats_this')
 def __initConfigActions(self):
 """
 Private method to create the Settings actions.
 """
-self.prefAct = E5Action(
+self.prefAct = EricAction(
 self.tr('Preferences'),
 UI.PixmapCache.getIcon("configure"),
 self.tr('&Preferences...'),
 0, 0, self, 'hexEditor_settings_preferences')
 self.prefAct.setStatusTip(self.tr(
 """ binary data.</p>"""
 ))
 self.__sbSize.setFrameStyle(
 QFrame.Shape.StyledPanel | QFrame.Shadow.Plain)
-self.__sbEditMode = E5ClickableLabel(self.__statusBar)
+self.__sbEditMode = EricClickableLabel(self.__statusBar)
 self.__statusBar.addPermanentWidget(self.__sbEditMode)
 self.__sbEditMode.setWhatsThis(self.tr(
 """<p>This part of the status bar displays the edit mode.</p>"""
 ))
 self.__sbEditMode.setFrameStyle(
 QFrame.Shape.StyledPanel | QFrame.Shadow.Plain)
 self.__sbEditMode.clicked.connect(self.__toggleEditMode)
-self.__sbReadOnly = E5ClickableLabel(self.__statusBar)
+self.__sbReadOnly = EricClickableLabel(self.__statusBar)
 self.__statusBar.addPermanentWidget(self.__sbReadOnly)
 self.__sbReadOnly.setWhatsThis(self.tr(
 """<p>This part of the status bar displays the read"""
 """ only mode.</p>"""
 ))
 self.__project is not None and
 self.__project.isOpen()
 ):
 self.__lastOpenPath = self.__project.getProjectPath()
-fileName = E5FileDialog.getOpenFileName(
+fileName = EricFileDialog.getOpenFileName(
 self,
 self.tr("Open binary file in new window"),
 self.__lastOpenPath,
 self.tr("All Files (*)"))
 if fileName:
 @return flag indicating, if it is ok to continue
 @rtype bool
 """
 if self.__editor.isModified():
-ret = E5MessageBox.okToClearData(
+ret = EricMessageBox.okToClearData(
 self,
 self.tr("eric Hex Editor"),
 self.tr("""The loaded file has unsaved changes."""),
 self.__saveHexFile)
 if not ret:
 @param fileName name of the binary file to load
 @type str
 """
 file = QFile(fileName)
 if not file.exists():
-E5MessageBox.warning(
+EricMessageBox.warning(
 self, self.tr("eric Hex Editor"),
 self.tr("The file '{0}' does not exist.")
 .format(fileName))
 return
 if not file.open(QFile.ReadOnly):
-E5MessageBox.warning(
+EricMessageBox.warning(
 self, self.tr("eric Hex Editor"),
 self.tr("Cannot read file '{0}:\n{1}.")
 .format(fileName, file.errorString()))
 return
 self.__project is not None and
 self.__project.isOpen()
 ):
 self.__lastOpenPath = self.__project.getProjectPath()
-fileName = E5FileDialog.getOpenFileName(
+fileName = EricFileDialog.getOpenFileName(
 self,
 self.tr("Open binary file"),
 self.__lastOpenPath,
 self.tr("All Files (*)"))
 if fileName:
 ):
 self.__lastSavePath = self.__project.getProjectPath()
 if not self.__lastSavePath and self.__lastOpenPath:
 self.__lastSavePath = self.__lastOpenPath
-fileName = E5FileDialog.getSaveFileName(
+fileName = EricFileDialog.getSaveFileName(
 self,
 self.tr("Save binary file"),
 self.__lastSavePath,
 self.tr("All Files (*)"),
-E5FileDialog.DontConfirmOverwrite)
+EricFileDialog.DontConfirmOverwrite)
 if not fileName:
 return False
 if QFileInfo(fileName).exists():
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self,
 self.tr("Save binary file"),
 self.tr("<p>The file <b>{0}</b> already exists."
 " Overwrite it?</p>").format(fileName),
-icon=E5MessageBox.Warning)
+icon=EricMessageBox.Warning)
 if not res:
 return False
 self.__lastSavePath = os.path.dirname(fileName)
 @return flag indicating success
 @rtype bool
 """
 file = QFile(fileName)
 if not file.open(QFile.WriteOnly):
-E5MessageBox.warning(
+EricMessageBox.warning(
 self, self.tr("eric Hex Editor"),
 self.tr("Cannot write file '{0}:\n{1}.")
 .format(fileName, file.errorString()))
 self.__checkActions()
 res = file.write(self.__editor.data()) != -1
 file.close()
 if not res:
-E5MessageBox.warning(
+EricMessageBox.warning(
 self, self.tr("eric Hex Editor"),
 self.tr("Cannot write file '{0}:\n{1}.")
 .format(fileName, file.errorString()))
 self.__checkActions()
 ):
 savePath = self.__project.getProjectPath()
 if not savePath and self.__lastOpenPath:
 savePath = self.__lastOpenPath
-fileName, selectedFilter = E5FileDialog.getSaveFileNameAndFilter(
+fileName, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
 self,
 self.tr("Save to readable file"),
 savePath,
 self.tr("Text Files (*.txt);;All Files (*)"),
 self.tr("Text Files (*.txt)"),
-E5FileDialog.DontConfirmOverwrite)
+EricFileDialog.DontConfirmOverwrite)
 if not fileName:
 return
 ext = QFileInfo(fileName).suffix()
 if not ext:
 ex = selectedFilter.split("(*")[1].split(")")[0]
 if ex:
 fileName += ex
 if QFileInfo(fileName).exists():
-res = E5MessageBox.yesNo(
+res = EricMessageBox.yesNo(
 self,
 self.tr("Save to readable file"),
 self.tr("<p>The file <b>{0}</b> already exists."
 " Overwrite it?</p>").format(fileName),
-icon=E5MessageBox.Warning)
+icon=EricMessageBox.Warning)
 if not res:
 return
 file = QFile(fileName)
 if not file.open(QFile.WriteOnly):
-E5MessageBox.warning(
+EricMessageBox.warning(
 self, self.tr("eric Hex Editor"),
 self.tr("Cannot write file '{0}:\n{1}.")
 .format(fileName, file.errorString()))
 return
 )
 res = file.write(readableData.encode("latin1")) != -1
 file.close()
 if not res:
-E5MessageBox.warning(
+EricMessageBox.warning(
 self, self.tr("eric Hex Editor"),
 self.tr("Cannot write file '{0}:\n{1}.")
 .format(fileName, file.errorString()))
 return
 def __about(self):
 """
 Private slot to show a little About message.
 """
-E5MessageBox.about(
+EricMessageBox.about(
 self, self.tr("About eric Hex Editor"),
 self.tr("The eric Hex Editor is a simple editor component"
 " to edit binary files."))
 def __aboutQt(self):
 """
 Private slot to handle the About Qt dialog.
 """
-E5MessageBox.aboutQt(self, "eric Hex Editor")
+EricMessageBox.aboutQt(self, "eric Hex Editor")
 def __whatsThis(self):
 """
 Private slot called in to enter Whats This mode.
 """

Mercurial Repositories > eric / file comparison

comparison: eric7/HexEdit/HexEditMainWindow.py

eric7/HexEdit/HexEditMainWindow.py