eric: comparison src/eric7/IconEditor/IconEditorWindow.py

-:e9e7eca7efee
+:bf71ee032bb4
 import os
 import contextlib
 import pathlib
 from PyQt6.QtCore import pyqtSignal, Qt, QSize, QSignalMapper, QEvent
-from PyQt6.QtGui import (
+from PyQt6.QtGui import QPalette, QImage, QImageReader, QImageWriter, QKeySequence
-QPalette, QImage, QImageReader, QImageWriter, QKeySequence
-)
 from PyQt6.QtWidgets import QScrollArea, QLabel, QDockWidget, QWhatsThis
 from EricGui.EricAction import EricAction, createActionGroup
 from EricWidgets import EricFileDialog, EricMessageBox
 from EricWidgets.EricMainWindow import EricMainWindow
 class IconEditorWindow(EricMainWindow):
 """
 Class implementing the web browser main window.
 @signal editorClosed() emitted after the window was requested to close down
 """
 editorClosed = pyqtSignal()
 windows = []
-def __init__(self, fileName="", parent=None, fromEric=False,
+def __init__(
-initShortcutsOnly=False, project=None):
+self,
+fileName="",
+parent=None,
+fromEric=False,
+initShortcutsOnly=False,
+project=None,
+):
 """
 Constructor
 @param fileName name of a file to load on startup (string)
 @param parent parent widget of this window (QWidget)
 @param fromEric flag indicating whether it was called from within
 eric (boolean)
 @param initShortcutsOnly flag indicating to just initialize the
 keyboard shortcuts (boolean)
 @param project reference to the project object (Project)
 """
 super().__init__(parent)
 self.setObjectName("eric7_icon_editor")
 self.fromEric = fromEric
 self.initShortcutsOnly = initShortcutsOnly
 self.setWindowIcon(UI.PixmapCache.getIcon("iconEditor"))
 if self.initShortcutsOnly:
 self.__initActions()
 else:
 if not self.fromEric:
-self.setStyle(Preferences.getUI("Style"),
+self.setStyle(
-Preferences.getUI("StyleSheet"))
+Preferences.getUI("Style"), Preferences.getUI("StyleSheet")
+)
 self.__editor = IconEditorGrid()
 self.__scrollArea = QScrollArea()
 self.__scrollArea.setWidget(self.__editor)
-self.__scrollArea.viewport().setBackgroundRole(
+self.__scrollArea.viewport().setBackgroundRole(QPalette.ColorRole.Dark)
-QPalette.ColorRole.Dark)
 self.__scrollArea.viewport().setAutoFillBackground(True)
 self.setCentralWidget(self.__scrollArea)
 g = Preferences.getGeometry("IconEditorGeometry")
 if g.isEmpty():
 s = QSize(600, 500)
 self.resize(s)
 else:
 self.restoreGeometry(g)
 self.__initActions()
 self.__initMenus()
 self.__initToolbars()
 self.__createStatusBar()
 self.__initFileFilters()
 self.__createPaletteDock()
 self.__palette.previewChanged(self.__editor.previewPixmap())
 self.__palette.colorChanged(self.__editor.penColor())
 self.__palette.setCompositingMode(self.__editor.compositingMode())
 self.__class__.windows.append(self)
 state = Preferences.getIconEditor("IconEditorState")
 self.restoreState(state)
 self.__editor.imageChanged.connect(self.__modificationChanged)
 self.__editor.positionChanged.connect(self.__updatePosition)
 self.__editor.sizeChanged.connect(self.__updateSize)
 self.__editor.previewChanged.connect(self.__palette.previewChanged)
 self.__editor.colorChanged.connect(self.__palette.colorChanged)
 self.__palette.colorSelected.connect(self.__editor.setPenColor)
-self.__palette.compositingChanged.connect(
+self.__palette.compositingChanged.connect(self.__editor.setCompositingMode)
-self.__editor.setCompositingMode)
 self.__setCurrentFile("")
 if fileName:
 self.__loadIconFile(fileName)
 self.__checkActions()
 self.__project = project
 self.__lastOpenPath = ""
 self.__lastSavePath = ""
 self.grabGesture(Qt.GestureType.PinchGesture)
 def __initFileFilters(self):
 """
 Private method to define the supported image file filters.
 """
 filters = {
-'bmp': self.tr("Windows Bitmap File (*.bmp)"),
+"bmp": self.tr("Windows Bitmap File (*.bmp)"),
-'cur': self.tr("Windows Cursor File (*.cur)"),
+"cur": self.tr("Windows Cursor File (*.cur)"),
-'dds': self.tr("DirectDraw-Surface File (*.dds)"),
+"dds": self.tr("DirectDraw-Surface File (*.dds)"),
-'gif': self.tr("Graphic Interchange Format File (*.gif)"),
+"gif": self.tr("Graphic Interchange Format File (*.gif)"),
-'icns': self.tr("Apple Icon File (*.icns)"),
+"icns": self.tr("Apple Icon File (*.icns)"),
-'ico': self.tr("Windows Icon File (*.ico)"),
+"ico": self.tr("Windows Icon File (*.ico)"),
-'jp2': self.tr("JPEG2000 File (*.jp2)"),
+"jp2": self.tr("JPEG2000 File (*.jp2)"),
-'jpg': self.tr("JPEG File (*.jpg)"),
+"jpg": self.tr("JPEG File (*.jpg)"),
-'jpeg': self.tr("JPEG File (*.jpeg)"),
+"jpeg": self.tr("JPEG File (*.jpeg)"),
-'mng': self.tr("Multiple-Image Network Graphics File (*.mng)"),
+"mng": self.tr("Multiple-Image Network Graphics File (*.mng)"),
-'pbm': self.tr("Portable Bitmap File (*.pbm)"),
+"pbm": self.tr("Portable Bitmap File (*.pbm)"),
-'pcx': self.tr("Paintbrush Bitmap File (*.pcx)"),
+"pcx": self.tr("Paintbrush Bitmap File (*.pcx)"),
-'pgm': self.tr("Portable Graymap File (*.pgm)"),
+"pgm": self.tr("Portable Graymap File (*.pgm)"),
-'png': self.tr("Portable Network Graphics File (*.png)"),
+"png": self.tr("Portable Network Graphics File (*.png)"),
-'ppm': self.tr("Portable Pixmap File (*.ppm)"),
+"ppm": self.tr("Portable Pixmap File (*.ppm)"),
-'sgi': self.tr("Silicon Graphics Image File (*.sgi)"),
+"sgi": self.tr("Silicon Graphics Image File (*.sgi)"),
-'svg': self.tr("Scalable Vector Graphics File (*.svg)"),
+"svg": self.tr("Scalable Vector Graphics File (*.svg)"),
-'svgz': self.tr("Compressed Scalable Vector Graphics File"
+"svgz": self.tr("Compressed Scalable Vector Graphics File" " (*.svgz)"),
-" (*.svgz)"),
+"tga": self.tr("Targa Graphic File (*.tga)"),
-'tga': self.tr("Targa Graphic File (*.tga)"),
+"tif": self.tr("TIFF File (*.tif)"),
-'tif': self.tr("TIFF File (*.tif)"),
+"tiff": self.tr("TIFF File (*.tiff)"),
-'tiff': self.tr("TIFF File (*.tiff)"),
+"wbmp": self.tr("WAP Bitmap File (*.wbmp)"),
-'wbmp': self.tr("WAP Bitmap File (*.wbmp)"),
+"webp": self.tr("WebP Image File (*.webp)"),
-'webp': self.tr("WebP Image File (*.webp)"),
+"xbm": self.tr("X11 Bitmap File (*.xbm)"),
-'xbm': self.tr("X11 Bitmap File (*.xbm)"),
+"xpm": self.tr("X11 Pixmap File (*.xpm)"),
-'xpm': self.tr("X11 Pixmap File (*.xpm)"),
 }
 inputFormats = []
 readFormats = QImageReader.supportedImageFormats()
 for readFormat in readFormats:
 with contextlib.suppress(KeyError):
 inputFormats.append(filters[bytes(readFormat).decode()])
 inputFormats.sort()
 inputFormats.append(self.tr("All Files (*)"))
-self.__inputFilter = ';;'.join(inputFormats)
+self.__inputFilter = ";;".join(inputFormats)
 outputFormats = []
 writeFormats = QImageWriter.supportedImageFormats()
 for writeFormat in writeFormats:
 with contextlib.suppress(KeyError):
 outputFormats.append(filters[bytes(writeFormat).decode()])
 outputFormats.sort()
-self.__outputFilter = ';;'.join(outputFormats)
+self.__outputFilter = ";;".join(outputFormats)
-self.__defaultFilter = filters['png']
+self.__defaultFilter = filters["png"]
 def __initActions(self):
 """
 Private method to define the user interface actions.
 """
 # list of all actions
 self.__actions = []
 self.__initFileActions()
 self.__initEditActions()
 self.__initViewActions()
 self.__initToolsActions()
 self.__initHelpActions()
 def __initFileActions(self):
 """
 Private method to define the file related user interface actions.
 """
 self.newAct = EricAction(
-self.tr('New'),
+self.tr("New"),
 UI.PixmapCache.getIcon("new"),
-self.tr('&New'),
+self.tr("&New"),
 QKeySequence(self.tr("Ctrl+N", "File|New")),
-0, self, 'iconEditor_file_new')
+0,
-self.newAct.setStatusTip(self.tr('Create a new icon'))
+self,
-self.newAct.setWhatsThis(self.tr(
+"iconEditor_file_new",
-"""<b>New</b>"""
+)
-"""<p>This creates a new icon.</p>"""
+self.newAct.setStatusTip(self.tr("Create a new icon"))
-))
+self.newAct.setWhatsThis(
+self.tr("""<b>New</b>""" """<p>This creates a new icon.</p>""")
+)
 self.newAct.triggered.connect(self.__newIcon)
 self.__actions.append(self.newAct)
 self.newWindowAct = EricAction(
-self.tr('New Window'),
+self.tr("New Window"),
 UI.PixmapCache.getIcon("newWindow"),
-self.tr('New &Window'),
+self.tr("New &Window"),
-0, 0, self, 'iconEditor_file_new_window')
+0,
-self.newWindowAct.setStatusTip(self.tr(
+0,
-'Open a new icon editor window'))
+self,
-self.newWindowAct.setWhatsThis(self.tr(
+"iconEditor_file_new_window",
-"""<b>New Window</b>"""
+)
-"""<p>This opens a new icon editor window.</p>"""
+self.newWindowAct.setStatusTip(self.tr("Open a new icon editor window"))
-))
+self.newWindowAct.setWhatsThis(
+self.tr(
+"""<b>New Window</b>"""
+"""<p>This opens a new icon editor window.</p>"""
+)
+)
 self.newWindowAct.triggered.connect(self.__newWindow)
 self.__actions.append(self.newWindowAct)
 self.openAct = EricAction(
-self.tr('Open'),
+self.tr("Open"),
 UI.PixmapCache.getIcon("open"),
-self.tr('&Open...'),
+self.tr("&Open..."),
 QKeySequence(self.tr("Ctrl+O", "File|Open")),
-0, self, 'iconEditor_file_open')
+0,
-self.openAct.setStatusTip(self.tr('Open an icon file for editing'))
+self,
-self.openAct.setWhatsThis(self.tr(
+"iconEditor_file_open",
-"""<b>Open File</b>"""
+)
-"""<p>This opens a new icon file for editing."""
+self.openAct.setStatusTip(self.tr("Open an icon file for editing"))
-""" It pops up a file selection dialog.</p>"""
+self.openAct.setWhatsThis(
-))
+self.tr(
+"""<b>Open File</b>"""
+"""<p>This opens a new icon file for editing."""
+""" It pops up a file selection dialog.</p>"""
+)
+)
 self.openAct.triggered.connect(self.__openIcon)
 self.__actions.append(self.openAct)
 self.saveAct = EricAction(
-self.tr('Save'),
+self.tr("Save"),
 UI.PixmapCache.getIcon("fileSave"),
-self.tr('&Save'),
+self.tr("&Save"),
 QKeySequence(self.tr("Ctrl+S", "File|Save")),
-0, self, 'iconEditor_file_save')
+0,
-self.saveAct.setStatusTip(self.tr('Save the current icon'))
+self,
-self.saveAct.setWhatsThis(self.tr(
+"iconEditor_file_save",
-"""<b>Save File</b>"""
+)
-"""<p>Save the contents of the icon editor window.</p>"""
+self.saveAct.setStatusTip(self.tr("Save the current icon"))
-))
+self.saveAct.setWhatsThis(
+self.tr(
+"""<b>Save File</b>"""
+"""<p>Save the contents of the icon editor window.</p>"""
+)
+)
 self.saveAct.triggered.connect(self.__saveIcon)
 self.__actions.append(self.saveAct)
 self.saveAsAct = EricAction(
-self.tr('Save As'),
+self.tr("Save As"),
 UI.PixmapCache.getIcon("fileSaveAs"),
-self.tr('Save &As...'),
+self.tr("Save &As..."),
 QKeySequence(self.tr("Shift+Ctrl+S", "File|Save As")),
-0, self, 'iconEditor_file_save_as')
+0,
-self.saveAsAct.setStatusTip(
+self,
-self.tr('Save the current icon to a new file'))
+"iconEditor_file_save_as",
-self.saveAsAct.setWhatsThis(self.tr(
+)
-"""<b>Save As...</b>"""
+self.saveAsAct.setStatusTip(self.tr("Save the current icon to a new file"))
-"""<p>Saves the current icon to a new file.</p>"""
+self.saveAsAct.setWhatsThis(
-))
+self.tr(
+"""<b>Save As...</b>"""
+"""<p>Saves the current icon to a new file.</p>"""
+)
+)
 self.saveAsAct.triggered.connect(self.__saveIconAs)
 self.__actions.append(self.saveAsAct)
 self.closeAct = EricAction(
-self.tr('Close'),
+self.tr("Close"),
 UI.PixmapCache.getIcon("close"),
-self.tr('&Close'),
+self.tr("&Close"),
 QKeySequence(self.tr("Ctrl+W", "File|Close")),
-0, self, 'iconEditor_file_close')
+0,
-self.closeAct.setStatusTip(self.tr(
+self,
-'Close the current icon editor window'))
+"iconEditor_file_close",
-self.closeAct.setWhatsThis(self.tr(
+)
-"""<b>Close</b>"""
+self.closeAct.setStatusTip(self.tr("Close the current icon editor window"))
-"""<p>Closes the current icon editor window.</p>"""
+self.closeAct.setWhatsThis(
-))
+self.tr(
+"""<b>Close</b>""" """<p>Closes the current icon editor window.</p>"""
+)
+)
 self.closeAct.triggered.connect(self.close)
 self.__actions.append(self.closeAct)
 self.closeAllAct = EricAction(
-self.tr('Close All'),
+self.tr("Close All"),
-self.tr('Close &All'),
+self.tr("Close &All"),
-0, 0, self, 'iconEditor_file_close_all')
+0,
-self.closeAllAct.setStatusTip(self.tr(
+0,
-'Close all icon editor windows'))
+self,
-self.closeAllAct.setWhatsThis(self.tr(
+"iconEditor_file_close_all",
-"""<b>Close All</b>"""
+)
-"""<p>Closes all icon editor windows except the first one.</p>"""
+self.closeAllAct.setStatusTip(self.tr("Close all icon editor windows"))
-))
+self.closeAllAct.setWhatsThis(
+self.tr(
+"""<b>Close All</b>"""
+"""<p>Closes all icon editor windows except the first one.</p>"""
+)
+)
 self.closeAllAct.triggered.connect(self.__closeAll)
 self.__actions.append(self.closeAllAct)
 self.closeOthersAct = EricAction(
-self.tr('Close Others'),
+self.tr("Close Others"),
-self.tr('Close Others'),
+self.tr("Close Others"),
-0, 0, self, 'iconEditor_file_close_others')
+0,
-self.closeOthersAct.setStatusTip(self.tr(
+0,
-'Close all other icon editor windows'))
+self,
-self.closeOthersAct.setWhatsThis(self.tr(
+"iconEditor_file_close_others",
-"""<b>Close Others</b>"""
+)
-"""<p>Closes all other icon editor windows.</p>"""
+self.closeOthersAct.setStatusTip(self.tr("Close all other icon editor windows"))
-))
+self.closeOthersAct.setWhatsThis(
+self.tr(
+"""<b>Close Others</b>"""
+"""<p>Closes all other icon editor windows.</p>"""
+)
+)
 self.closeOthersAct.triggered.connect(self.__closeOthers)
 self.__actions.append(self.closeOthersAct)
 self.exitAct = EricAction(
-self.tr('Quit'),
+self.tr("Quit"),
 UI.PixmapCache.getIcon("exit"),
-self.tr('&Quit'),
+self.tr("&Quit"),
 QKeySequence(self.tr("Ctrl+Q", "File|Quit")),
-0, self, 'iconEditor_file_quit')
+0,
-self.exitAct.setStatusTip(self.tr('Quit the icon editor'))
+self,
-self.exitAct.setWhatsThis(self.tr(
+"iconEditor_file_quit",
-"""<b>Quit</b>"""
+)
-"""<p>Quit the icon editor.</p>"""
+self.exitAct.setStatusTip(self.tr("Quit the icon editor"))
-))
+self.exitAct.setWhatsThis(
+self.tr("""<b>Quit</b>""" """<p>Quit the icon editor.</p>""")
+)
 if not self.fromEric:
 self.exitAct.triggered.connect(self.__closeAll)
 self.__actions.append(self.exitAct)
 def __initEditActions(self):
 """
 Private method to create the Edit actions.
 """
 self.undoAct = EricAction(
-self.tr('Undo'),
+self.tr("Undo"),
 UI.PixmapCache.getIcon("editUndo"),
-self.tr('&Undo'),
+self.tr("&Undo"),
 QKeySequence(self.tr("Ctrl+Z", "Edit|Undo")),
 QKeySequence(self.tr("Alt+Backspace", "Edit|Undo")),
-self, 'iconEditor_edit_undo')
+self,
-self.undoAct.setStatusTip(self.tr('Undo the last change'))
+"iconEditor_edit_undo",
-self.undoAct.setWhatsThis(self.tr(
+)
-"""<b>Undo</b>"""
+self.undoAct.setStatusTip(self.tr("Undo the last change"))
-"""<p>Undo the last change done.</p>"""
+self.undoAct.setWhatsThis(
-))
+self.tr("""<b>Undo</b>""" """<p>Undo the last change done.</p>""")
+)
 self.undoAct.triggered.connect(self.__editor.editUndo)
 self.__actions.append(self.undoAct)
 self.redoAct = EricAction(
-self.tr('Redo'),
+self.tr("Redo"),
 UI.PixmapCache.getIcon("editRedo"),
-self.tr('&Redo'),
+self.tr("&Redo"),
 QKeySequence(self.tr("Ctrl+Shift+Z", "Edit|Redo")),
-0, self, 'iconEditor_edit_redo')
+0,
-self.redoAct.setStatusTip(self.tr('Redo the last change'))
+self,
-self.redoAct.setWhatsThis(self.tr(
+"iconEditor_edit_redo",
-"""<b>Redo</b>"""
+)
-"""<p>Redo the last change done.</p>"""
+self.redoAct.setStatusTip(self.tr("Redo the last change"))
-))
+self.redoAct.setWhatsThis(
+self.tr("""<b>Redo</b>""" """<p>Redo the last change done.</p>""")
+)
 self.redoAct.triggered.connect(self.__editor.editRedo)
 self.__actions.append(self.redoAct)
 self.cutAct = EricAction(
-self.tr('Cut'),
+self.tr("Cut"),
 UI.PixmapCache.getIcon("editCut"),
-self.tr('Cu&t'),
+self.tr("Cu&t"),
 QKeySequence(self.tr("Ctrl+X", "Edit|Cut")),
 QKeySequence(self.tr("Shift+Del", "Edit|Cut")),
-self, 'iconEditor_edit_cut')
+self,
-self.cutAct.setStatusTip(self.tr('Cut the selection'))
+"iconEditor_edit_cut",
-self.cutAct.setWhatsThis(self.tr(
+)
-"""<b>Cut</b>"""
+self.cutAct.setStatusTip(self.tr("Cut the selection"))
-"""<p>Cut the selected image area to the clipboard.</p>"""
+self.cutAct.setWhatsThis(
-))
+self.tr(
+"""<b>Cut</b>"""
+"""<p>Cut the selected image area to the clipboard.</p>"""
+)
+)
 self.cutAct.triggered.connect(self.__editor.editCut)
 self.__actions.append(self.cutAct)
 self.copyAct = EricAction(
-self.tr('Copy'),
+self.tr("Copy"),
 UI.PixmapCache.getIcon("editCopy"),
-self.tr('&Copy'),
+self.tr("&Copy"),
 QKeySequence(self.tr("Ctrl+C", "Edit|Copy")),
 QKeySequence(self.tr("Ctrl+Ins", "Edit|Copy")),
-self, 'iconEditor_edit_copy')
+self,
-self.copyAct.setStatusTip(self.tr('Copy the selection'))
+"iconEditor_edit_copy",
-self.copyAct.setWhatsThis(self.tr(
+)
-"""<b>Copy</b>"""
+self.copyAct.setStatusTip(self.tr("Copy the selection"))
-"""<p>Copy the selected image area to the clipboard.</p>"""
+self.copyAct.setWhatsThis(
-))
+self.tr(
+"""<b>Copy</b>"""
+"""<p>Copy the selected image area to the clipboard.</p>"""
+)
+)
 self.copyAct.triggered.connect(self.__editor.editCopy)
 self.__actions.append(self.copyAct)
 self.pasteAct = EricAction(
-self.tr('Paste'),
+self.tr("Paste"),
 UI.PixmapCache.getIcon("editPaste"),
-self.tr('&Paste'),
+self.tr("&Paste"),
 QKeySequence(self.tr("Ctrl+V", "Edit|Paste")),
 QKeySequence(self.tr("Shift+Ins", "Edit|Paste")),
-self, 'iconEditor_edit_paste')
+self,
-self.pasteAct.setStatusTip(self.tr('Paste the clipboard image'))
+"iconEditor_edit_paste",
-self.pasteAct.setWhatsThis(self.tr(
+)
-"""<b>Paste</b>"""
+self.pasteAct.setStatusTip(self.tr("Paste the clipboard image"))
-"""<p>Paste the clipboard image.</p>"""
+self.pasteAct.setWhatsThis(
-))
+self.tr("""<b>Paste</b>""" """<p>Paste the clipboard image.</p>""")
+)
 self.pasteAct.triggered.connect(self.__editor.editPaste)
 self.__actions.append(self.pasteAct)
 self.pasteNewAct = EricAction(
-self.tr('Paste as New'),
+self.tr("Paste as New"),
-self.tr('Paste as &New'),
+self.tr("Paste as &New"),
-0, 0, self, 'iconEditor_edit_paste_as_new')
+0,
-self.pasteNewAct.setStatusTip(self.tr(
+0,
-'Paste the clipboard image replacing the current one'))
+self,
-self.pasteNewAct.setWhatsThis(self.tr(
+"iconEditor_edit_paste_as_new",
-"""<b>Paste as New</b>"""
+)
-"""<p>Paste the clipboard image replacing the current one.</p>"""
+self.pasteNewAct.setStatusTip(
-))
+self.tr("Paste the clipboard image replacing the current one")
+)
+self.pasteNewAct.setWhatsThis(
+self.tr(
+"""<b>Paste as New</b>"""
+"""<p>Paste the clipboard image replacing the current one.</p>"""
+)
+)
 self.pasteNewAct.triggered.connect(self.__editor.editPasteAsNew)
 self.__actions.append(self.pasteNewAct)
 self.deleteAct = EricAction(
-self.tr('Clear'),
+self.tr("Clear"),
 UI.PixmapCache.getIcon("editDelete"),
-self.tr('Cl&ear'),
+self.tr("Cl&ear"),
 QKeySequence(self.tr("Alt+Shift+C", "Edit|Clear")),
 0,
-self, 'iconEditor_edit_clear')
+self,
-self.deleteAct.setStatusTip(self.tr('Clear the icon image'))
+"iconEditor_edit_clear",
-self.deleteAct.setWhatsThis(self.tr(
+)
-"""<b>Clear</b>"""
+self.deleteAct.setStatusTip(self.tr("Clear the icon image"))
-"""<p>Clear the icon image and set it to be completely"""
+self.deleteAct.setWhatsThis(
-""" transparent.</p>"""
+self.tr(
-))
+"""<b>Clear</b>"""
+"""<p>Clear the icon image and set it to be completely"""
+""" transparent.</p>"""
+)
+)
 self.deleteAct.triggered.connect(self.__editor.editClear)
 self.__actions.append(self.deleteAct)
 self.selectAllAct = EricAction(
-self.tr('Select All'),
+self.tr("Select All"),
-self.tr('&Select All'),
+self.tr("&Select All"),
 QKeySequence(self.tr("Ctrl+A", "Edit|Select All")),
 0,
-self, 'iconEditor_edit_select_all')
+self,
-self.selectAllAct.setStatusTip(self.tr(
+"iconEditor_edit_select_all",
-'Select the complete icon image'))
+)
-self.selectAllAct.setWhatsThis(self.tr(
+self.selectAllAct.setStatusTip(self.tr("Select the complete icon image"))
-"""<b>Select All</b>"""
+self.selectAllAct.setWhatsThis(
-"""<p>Selects the complete icon image.</p>"""
+self.tr(
-))
+"""<b>Select All</b>""" """<p>Selects the complete icon image.</p>"""
+)
+)
 self.selectAllAct.triggered.connect(self.__editor.editSelectAll)
 self.__actions.append(self.selectAllAct)
 self.resizeAct = EricAction(
-self.tr('Change Size'),
+self.tr("Change Size"),
 UI.PixmapCache.getIcon("transformResize"),
-self.tr('Change Si&ze...'),
+self.tr("Change Si&ze..."),
-0, 0,
+0,
-self, 'iconEditor_edit_change_size')
+0,
-self.resizeAct.setStatusTip(self.tr('Change the icon size'))
+self,
-self.resizeAct.setWhatsThis(self.tr(
+"iconEditor_edit_change_size",
-"""<b>Change Size...</b>"""
+)
-"""<p>Changes the icon size.</p>"""
+self.resizeAct.setStatusTip(self.tr("Change the icon size"))
-))
+self.resizeAct.setWhatsThis(
+self.tr("""<b>Change Size...</b>""" """<p>Changes the icon size.</p>""")
+)
 self.resizeAct.triggered.connect(self.__editor.editResize)
 self.__actions.append(self.resizeAct)
 self.grayscaleAct = EricAction(
-self.tr('Grayscale'),
+self.tr("Grayscale"),
 UI.PixmapCache.getIcon("grayscale"),
-self.tr('&Grayscale'),
+self.tr("&Grayscale"),
-0, 0,
+0,
-self, 'iconEditor_edit_grayscale')
+0,
-self.grayscaleAct.setStatusTip(self.tr(
+self,
-'Change the icon to grayscale'))
+"iconEditor_edit_grayscale",
-self.grayscaleAct.setWhatsThis(self.tr(
+)
-"""<b>Grayscale</b>"""
+self.grayscaleAct.setStatusTip(self.tr("Change the icon to grayscale"))
-"""<p>Changes the icon to grayscale.</p>"""
+self.grayscaleAct.setWhatsThis(
-))
+self.tr("""<b>Grayscale</b>""" """<p>Changes the icon to grayscale.</p>""")
+)
 self.grayscaleAct.triggered.connect(self.__editor.grayScale)
 self.__actions.append(self.grayscaleAct)
 self.redoAct.setEnabled(False)
 self.__editor.canRedoChanged.connect(self.redoAct.setEnabled)
 self.undoAct.setEnabled(False)
 self.__editor.canUndoChanged.connect(self.undoAct.setEnabled)
 self.cutAct.setEnabled(False)
 self.copyAct.setEnabled(False)
 self.__editor.selectionAvailable.connect(self.cutAct.setEnabled)
 self.__editor.selectionAvailable.connect(self.copyAct.setEnabled)
 self.pasteAct.setEnabled(self.__editor.canPaste())
 self.pasteNewAct.setEnabled(self.__editor.canPaste())
-self.__editor.clipboardImageAvailable.connect(
+self.__editor.clipboardImageAvailable.connect(self.pasteAct.setEnabled)
-self.pasteAct.setEnabled)
+self.__editor.clipboardImageAvailable.connect(self.pasteNewAct.setEnabled)
-self.__editor.clipboardImageAvailable.connect(
-self.pasteNewAct.setEnabled)
 def __initViewActions(self):
 """
 Private method to create the View actions.
 """
 self.zoomInAct = EricAction(
-self.tr('Zoom in'),
+self.tr("Zoom in"),
 UI.PixmapCache.getIcon("zoomIn"),
-self.tr('Zoom &in'),
+self.tr("Zoom &in"),
 QKeySequence(self.tr("Ctrl++", "View|Zoom in")),
-0, self, 'iconEditor_view_zoom_in')
+0,
-self.zoomInAct.setStatusTip(self.tr('Zoom in on the icon'))
+self,
-self.zoomInAct.setWhatsThis(self.tr(
+"iconEditor_view_zoom_in",
-"""<b>Zoom in</b>"""
+)
-"""<p>Zoom in on the icon. This makes the grid bigger.</p>"""
+self.zoomInAct.setStatusTip(self.tr("Zoom in on the icon"))
-))
+self.zoomInAct.setWhatsThis(
+self.tr(
+"""<b>Zoom in</b>"""
+"""<p>Zoom in on the icon. This makes the grid bigger.</p>"""
+)
+)
 self.zoomInAct.triggered.connect(self.__zoomIn)
 self.__actions.append(self.zoomInAct)
 self.zoomOutAct = EricAction(
-self.tr('Zoom out'),
+self.tr("Zoom out"),
 UI.PixmapCache.getIcon("zoomOut"),
-self.tr('Zoom &out'),
+self.tr("Zoom &out"),
 QKeySequence(self.tr("Ctrl+-", "View|Zoom out")),
-0, self, 'iconEditor_view_zoom_out')
+0,
-self.zoomOutAct.setStatusTip(self.tr('Zoom out on the icon'))
+self,
-self.zoomOutAct.setWhatsThis(self.tr(
+"iconEditor_view_zoom_out",
-"""<b>Zoom out</b>"""
+)
-"""<p>Zoom out on the icon. This makes the grid smaller.</p>"""
+self.zoomOutAct.setStatusTip(self.tr("Zoom out on the icon"))
-))
+self.zoomOutAct.setWhatsThis(
+self.tr(
+"""<b>Zoom out</b>"""
+"""<p>Zoom out on the icon. This makes the grid smaller.</p>"""
+)
+)
 self.zoomOutAct.triggered.connect(self.__zoomOut)
 self.__actions.append(self.zoomOutAct)
 self.zoomResetAct = EricAction(
-self.tr('Zoom reset'),
+self.tr("Zoom reset"),
 UI.PixmapCache.getIcon("zoomReset"),
-self.tr('Zoom &reset'),
+self.tr("Zoom &reset"),
 QKeySequence(self.tr("Ctrl+0", "View|Zoom reset")),
-0, self, 'iconEditor_view_zoom_reset')
+0,
-self.zoomResetAct.setStatusTip(self.tr(
+self,
-'Reset the zoom of the icon'))
+"iconEditor_view_zoom_reset",
-self.zoomResetAct.setWhatsThis(self.tr(
+)
-"""<b>Zoom reset</b>"""
+self.zoomResetAct.setStatusTip(self.tr("Reset the zoom of the icon"))
-"""<p>Reset the zoom of the icon. """
+self.zoomResetAct.setWhatsThis(
-"""This sets the zoom factor to 100%.</p>"""
+self.tr(
-))
+"""<b>Zoom reset</b>"""
+"""<p>Reset the zoom of the icon. """
+"""This sets the zoom factor to 100%.</p>"""
+)
+)
 self.zoomResetAct.triggered.connect(self.__zoomReset)
 self.__actions.append(self.zoomResetAct)
 self.showGridAct = EricAction(
-self.tr('Show Grid'),
+self.tr("Show Grid"),
 UI.PixmapCache.getIcon("grid"),
-self.tr('Show &Grid'),
+self.tr("Show &Grid"),
-0, 0,
+0,
-self, 'iconEditor_view_show_grid')
+0,
-self.showGridAct.setStatusTip(self.tr(
+self,
-'Toggle the display of the grid'))
+"iconEditor_view_show_grid",
-self.showGridAct.setWhatsThis(self.tr(
+)
-"""<b>Show Grid</b>"""
+self.showGridAct.setStatusTip(self.tr("Toggle the display of the grid"))
-"""<p>Toggle the display of the grid.</p>"""
+self.showGridAct.setWhatsThis(
-))
+self.tr("""<b>Show Grid</b>""" """<p>Toggle the display of the grid.</p>""")
+)
 self.showGridAct.triggered[bool].connect(self.__editor.setGridEnabled)
 self.__actions.append(self.showGridAct)
 self.showGridAct.setCheckable(True)
 self.showGridAct.setChecked(self.__editor.isGridEnabled())
 def __initToolsActions(self):
 """
 Private method to create the View actions.
 """
 self.esm = QSignalMapper(self)
 self.esm.mappedInt.connect(self.__editor.setTool)
 self.drawingActGrp = createActionGroup(self)
 self.drawingActGrp.setExclusive(True)
 self.drawPencilAct = EricAction(
-self.tr('Freehand'),
+self.tr("Freehand"),
 UI.PixmapCache.getIcon("drawBrush"),
-self.tr('&Freehand'),
+self.tr("&Freehand"),
-0, 0,
+0,
-self.drawingActGrp, 'iconEditor_tools_pencil')
+0,
-self.drawPencilAct.setWhatsThis(self.tr(
+self.drawingActGrp,
-"""<b>Free hand</b>"""
+"iconEditor_tools_pencil",
-"""<p>Draws non linear lines.</p>"""
+)
-))
+self.drawPencilAct.setWhatsThis(
+self.tr("""<b>Free hand</b>""" """<p>Draws non linear lines.</p>""")
+)
 self.drawPencilAct.setCheckable(True)
 self.esm.setMapping(self.drawPencilAct, IconEditorTool.PENCIL)
 self.drawPencilAct.triggered.connect(self.esm.map)
 self.__actions.append(self.drawPencilAct)
 self.drawColorPickerAct = EricAction(
-self.tr('Color Picker'),
+self.tr("Color Picker"),
 UI.PixmapCache.getIcon("colorPicker"),
-self.tr('&Color Picker'),
+self.tr("&Color Picker"),
-0, 0,
+0,
-self.drawingActGrp, 'iconEditor_tools_color_picker')
+0,
-self.drawColorPickerAct.setWhatsThis(self.tr(
+self.drawingActGrp,
-"""<b>Color Picker</b>"""
+"iconEditor_tools_color_picker",
-"""<p>The color of the pixel clicked on will become """
+)
-"""the current draw color.</p>"""
+self.drawColorPickerAct.setWhatsThis(
-))
+self.tr(
+"""<b>Color Picker</b>"""
+"""<p>The color of the pixel clicked on will become """
+"""the current draw color.</p>"""
+)
+)
 self.drawColorPickerAct.setCheckable(True)
-self.esm.setMapping(self.drawColorPickerAct,
+self.esm.setMapping(self.drawColorPickerAct, IconEditorTool.COLOR_PICKER)
-IconEditorTool.COLOR_PICKER)
 self.drawColorPickerAct.triggered.connect(self.esm.map)
 self.__actions.append(self.drawColorPickerAct)
 self.drawRectangleAct = EricAction(
-self.tr('Rectangle'),
+self.tr("Rectangle"),
 UI.PixmapCache.getIcon("drawRectangle"),
-self.tr('&Rectangle'),
+self.tr("&Rectangle"),
-0, 0,
+0,
-self.drawingActGrp, 'iconEditor_tools_rectangle')
+0,
-self.drawRectangleAct.setWhatsThis(self.tr(
+self.drawingActGrp,
-"""<b>Rectangle</b>"""
+"iconEditor_tools_rectangle",
-"""<p>Draw a rectangle.</p>"""
+)
-))
+self.drawRectangleAct.setWhatsThis(
+self.tr("""<b>Rectangle</b>""" """<p>Draw a rectangle.</p>""")
+)
 self.drawRectangleAct.setCheckable(True)
 self.esm.setMapping(self.drawRectangleAct, IconEditorTool.RECTANGLE)
 self.drawRectangleAct.triggered.connect(self.esm.map)
 self.__actions.append(self.drawRectangleAct)
 self.drawFilledRectangleAct = EricAction(
-self.tr('Filled Rectangle'),
+self.tr("Filled Rectangle"),
 UI.PixmapCache.getIcon("drawRectangleFilled"),
-self.tr('F&illed Rectangle'),
+self.tr("F&illed Rectangle"),
-0, 0,
+0,
-self.drawingActGrp, 'iconEditor_tools_filled_rectangle')
+0,
-self.drawFilledRectangleAct.setWhatsThis(self.tr(
+self.drawingActGrp,
-"""<b>Filled Rectangle</b>"""
+"iconEditor_tools_filled_rectangle",
-"""<p>Draw a filled rectangle.</p>"""
+)
-))
+self.drawFilledRectangleAct.setWhatsThis(
+self.tr("""<b>Filled Rectangle</b>""" """<p>Draw a filled rectangle.</p>""")
+)
 self.drawFilledRectangleAct.setCheckable(True)
-self.esm.setMapping(self.drawFilledRectangleAct,
+self.esm.setMapping(
-IconEditorTool.FILLED_RECTANGLE)
+self.drawFilledRectangleAct, IconEditorTool.FILLED_RECTANGLE
+)
 self.drawFilledRectangleAct.triggered.connect(self.esm.map)
 self.__actions.append(self.drawFilledRectangleAct)
 self.drawCircleAct = EricAction(
-self.tr('Circle'),
+self.tr("Circle"),
 UI.PixmapCache.getIcon("drawCircle"),
-self.tr('Circle'),
+self.tr("Circle"),
-0, 0,
+0,
-self.drawingActGrp, 'iconEditor_tools_circle')
+0,
-self.drawCircleAct.setWhatsThis(self.tr(
+self.drawingActGrp,
-"""<b>Circle</b>"""
+"iconEditor_tools_circle",
-"""<p>Draw a circle.</p>"""
+)
-))
+self.drawCircleAct.setWhatsThis(
+self.tr("""<b>Circle</b>""" """<p>Draw a circle.</p>""")
+)
 self.drawCircleAct.setCheckable(True)
 self.esm.setMapping(self.drawCircleAct, IconEditorTool.CIRCLE)
 self.drawCircleAct.triggered.connect(self.esm.map)
 self.__actions.append(self.drawCircleAct)
 self.drawFilledCircleAct = EricAction(
-self.tr('Filled Circle'),
+self.tr("Filled Circle"),
 UI.PixmapCache.getIcon("drawCircleFilled"),
-self.tr('Fille&d Circle'),
+self.tr("Fille&d Circle"),
-0, 0,
+0,
-self.drawingActGrp, 'iconEditor_tools_filled_circle')
+0,
-self.drawFilledCircleAct.setWhatsThis(self.tr(
+self.drawingActGrp,
-"""<b>Filled Circle</b>"""
+"iconEditor_tools_filled_circle",
-"""<p>Draw a filled circle.</p>"""
+)
-))
+self.drawFilledCircleAct.setWhatsThis(
+self.tr("""<b>Filled Circle</b>""" """<p>Draw a filled circle.</p>""")
+)
 self.drawFilledCircleAct.setCheckable(True)
-self.esm.setMapping(self.drawFilledCircleAct,
+self.esm.setMapping(self.drawFilledCircleAct, IconEditorTool.FILLED_CIRCLE)
-IconEditorTool.FILLED_CIRCLE)
 self.drawFilledCircleAct.triggered.connect(self.esm.map)
 self.__actions.append(self.drawFilledCircleAct)
 self.drawEllipseAct = EricAction(
-self.tr('Ellipse'),
+self.tr("Ellipse"),
 UI.PixmapCache.getIcon("drawEllipse"),
-self.tr('&Ellipse'),
+self.tr("&Ellipse"),
-0, 0,
+0,
-self.drawingActGrp, 'iconEditor_tools_ellipse')
+0,
-self.drawEllipseAct.setWhatsThis(self.tr(
+self.drawingActGrp,
-"""<b>Ellipse</b>"""
+"iconEditor_tools_ellipse",
-"""<p>Draw an ellipse.</p>"""
+)
-))
+self.drawEllipseAct.setWhatsThis(
+self.tr("""<b>Ellipse</b>""" """<p>Draw an ellipse.</p>""")
+)
 self.drawEllipseAct.setCheckable(True)
 self.esm.setMapping(self.drawEllipseAct, IconEditorTool.ELLIPSE)
 self.drawEllipseAct.triggered.connect(self.esm.map)
 self.__actions.append(self.drawEllipseAct)
 self.drawFilledEllipseAct = EricAction(
-self.tr('Filled Ellipse'),
+self.tr("Filled Ellipse"),
 UI.PixmapCache.getIcon("drawEllipseFilled"),
-self.tr('Fille&d Elli&pse'),
+self.tr("Fille&d Elli&pse"),
-0, 0,
+0,
-self.drawingActGrp, 'iconEditor_tools_filled_ellipse')
+0,
-self.drawFilledEllipseAct.setWhatsThis(self.tr(
+self.drawingActGrp,
-"""<b>Filled Ellipse</b>"""
+"iconEditor_tools_filled_ellipse",
-"""<p>Draw a filled ellipse.</p>"""
+)
-))
+self.drawFilledEllipseAct.setWhatsThis(
+self.tr("""<b>Filled Ellipse</b>""" """<p>Draw a filled ellipse.</p>""")
+)
 self.drawFilledEllipseAct.setCheckable(True)
-self.esm.setMapping(self.drawFilledEllipseAct,
+self.esm.setMapping(self.drawFilledEllipseAct, IconEditorTool.FILLED_ELLIPSE)
-IconEditorTool.FILLED_ELLIPSE)
 self.drawFilledEllipseAct.triggered.connect(self.esm.map)
 self.__actions.append(self.drawFilledEllipseAct)
 self.drawFloodFillAct = EricAction(
-self.tr('Flood Fill'),
+self.tr("Flood Fill"),
 UI.PixmapCache.getIcon("drawFill"),
-self.tr('Fl&ood Fill'),
+self.tr("Fl&ood Fill"),
-0, 0,
+0,
-self.drawingActGrp, 'iconEditor_tools_flood_fill')
+0,
-self.drawFloodFillAct.setWhatsThis(self.tr(
+self.drawingActGrp,
-"""<b>Flood Fill</b>"""
+"iconEditor_tools_flood_fill",
-"""<p>Fill adjoining pixels with the same color with """
+)
-"""the current color.</p>"""
+self.drawFloodFillAct.setWhatsThis(
-))
+self.tr(
+"""<b>Flood Fill</b>"""
+"""<p>Fill adjoining pixels with the same color with """
+"""the current color.</p>"""
+)
+)
 self.drawFloodFillAct.setCheckable(True)
 self.esm.setMapping(self.drawFloodFillAct, IconEditorTool.FILL)
 self.drawFloodFillAct.triggered.connect(self.esm.map)
 self.__actions.append(self.drawFloodFillAct)
 self.drawLineAct = EricAction(
-self.tr('Line'),
+self.tr("Line"),
 UI.PixmapCache.getIcon("drawLine"),
-self.tr('&Line'),
+self.tr("&Line"),
-0, 0,
+0,
-self.drawingActGrp, 'iconEditor_tools_line')
+0,
-self.drawLineAct.setWhatsThis(self.tr(
+self.drawingActGrp,
-"""<b>Line</b>"""
+"iconEditor_tools_line",
-"""<p>Draw a line.</p>"""
+)
-))
+self.drawLineAct.setWhatsThis(
+self.tr("""<b>Line</b>""" """<p>Draw a line.</p>""")
+)
 self.drawLineAct.setCheckable(True)
 self.esm.setMapping(self.drawLineAct, IconEditorTool.LINE)
 self.drawLineAct.triggered.connect(self.esm.map)
 self.__actions.append(self.drawLineAct)
 self.drawEraserAct = EricAction(
-self.tr('Eraser (Transparent)'),
+self.tr("Eraser (Transparent)"),
 UI.PixmapCache.getIcon("drawEraser"),
-self.tr('Eraser (&Transparent)'),
+self.tr("Eraser (&Transparent)"),
-0, 0,
+0,
-self.drawingActGrp, 'iconEditor_tools_eraser')
+0,
-self.drawEraserAct.setWhatsThis(self.tr(
+self.drawingActGrp,
-"""<b>Eraser (Transparent)</b>"""
+"iconEditor_tools_eraser",
-"""<p>Erase pixels by setting them to transparent.</p>"""
+)
-))
+self.drawEraserAct.setWhatsThis(
+self.tr(
+"""<b>Eraser (Transparent)</b>"""
+"""<p>Erase pixels by setting them to transparent.</p>"""
+)
+)
 self.drawEraserAct.setCheckable(True)
 self.esm.setMapping(self.drawEraserAct, IconEditorTool.RUBBER)
 self.drawEraserAct.triggered.connect(self.esm.map)
 self.__actions.append(self.drawEraserAct)
 self.drawRectangleSelectionAct = EricAction(
-self.tr('Rectangular Selection'),
+self.tr("Rectangular Selection"),
 UI.PixmapCache.getIcon("selectRectangle"),
-self.tr('Rect&angular Selection'),
+self.tr("Rect&angular Selection"),
-0, 0,
+0,
-self.drawingActGrp, 'iconEditor_tools_selection_rectangle')
+0,
-self.drawRectangleSelectionAct.setWhatsThis(self.tr(
+self.drawingActGrp,
-"""<b>Rectangular Selection</b>"""
+"iconEditor_tools_selection_rectangle",
-"""<p>Select a rectangular section of the icon using"""
+)
-""" the mouse.</p>"""
+self.drawRectangleSelectionAct.setWhatsThis(
-))
+self.tr(
+"""<b>Rectangular Selection</b>"""
+"""<p>Select a rectangular section of the icon using"""
+""" the mouse.</p>"""
+)
+)
 self.drawRectangleSelectionAct.setCheckable(True)
-self.esm.setMapping(self.drawRectangleSelectionAct,
+self.esm.setMapping(
-IconEditorTool.SELECT_RECTANGLE)
+self.drawRectangleSelectionAct, IconEditorTool.SELECT_RECTANGLE
+)
 self.drawRectangleSelectionAct.triggered.connect(self.esm.map)
 self.__actions.append(self.drawRectangleSelectionAct)
 self.drawCircleSelectionAct = EricAction(
-self.tr('Circular Selection'),
+self.tr("Circular Selection"),
 UI.PixmapCache.getIcon("selectCircle"),
-self.tr('Rect&angular Selection'),
+self.tr("Rect&angular Selection"),
-0, 0,
+0,
-self.drawingActGrp, 'iconEditor_tools_selection_circle')
+0,
-self.drawCircleSelectionAct.setWhatsThis(self.tr(
+self.drawingActGrp,
-"""<b>Circular Selection</b>"""
+"iconEditor_tools_selection_circle",
-"""<p>Select a circular section of the icon using"""
+)
-""" the mouse.</p>"""
+self.drawCircleSelectionAct.setWhatsThis(
-))
+self.tr(
+"""<b>Circular Selection</b>"""
+"""<p>Select a circular section of the icon using"""
+""" the mouse.</p>"""
+)
+)
 self.drawCircleSelectionAct.setCheckable(True)
-self.esm.setMapping(self.drawCircleSelectionAct,
+self.esm.setMapping(self.drawCircleSelectionAct, IconEditorTool.SELECT_CIRCLE)
-IconEditorTool.SELECT_CIRCLE)
 self.drawCircleSelectionAct.triggered.connect(self.esm.map)
 self.__actions.append(self.drawCircleSelectionAct)
 self.drawPencilAct.trigger()
 def __initHelpActions(self):
 """
 Private method to create the Help actions.
 """
 self.aboutAct = EricAction(
-self.tr('About'),
+self.tr("About"), self.tr("&About"), 0, 0, self, "iconEditor_help_about"
-self.tr('&About'),
+)
-0, 0, self, 'iconEditor_help_about')
+self.aboutAct.setStatusTip(self.tr("Display information about this software"))
-self.aboutAct.setStatusTip(self.tr(
+self.aboutAct.setWhatsThis(
-'Display information about this software'))
+self.tr(
-self.aboutAct.setWhatsThis(self.tr(
+"""<b>About</b>"""
-"""<b>About</b>"""
+"""<p>Display some information about this software.</p>"""
-"""<p>Display some information about this software.</p>"""))
+)
+)
 self.aboutAct.triggered.connect(self.__about)
 self.__actions.append(self.aboutAct)
 self.aboutQtAct = EricAction(
-self.tr('About Qt'),
+self.tr("About Qt"),
-self.tr('About &Qt'),
+self.tr("About &Qt"),
-0, 0, self, 'iconEditor_help_about_qt')
+0,
+0,
+self,
+"iconEditor_help_about_qt",
+)
 self.aboutQtAct.setStatusTip(
-self.tr('Display information about the Qt toolkit'))
+self.tr("Display information about the Qt toolkit")
-self.aboutQtAct.setWhatsThis(self.tr(
+)
-"""<b>About Qt</b>"""
+self.aboutQtAct.setWhatsThis(
-"""<p>Display some information about the Qt toolkit.</p>"""
+self.tr(
-))
+"""<b>About Qt</b>"""
+"""<p>Display some information about the Qt toolkit.</p>"""
+)
+)
 self.aboutQtAct.triggered.connect(self.__aboutQt)
 self.__actions.append(self.aboutQtAct)
 self.whatsThisAct = EricAction(
-self.tr('What\'s This?'),
+self.tr("What's This?"),
 UI.PixmapCache.getIcon("whatsThis"),
-self.tr('&What\'s This?'),
+self.tr("&What's This?"),
 QKeySequence(self.tr("Shift+F1", "Help|What's This?'")),
-0, self, 'iconEditor_help_whats_this')
+0,
-self.whatsThisAct.setStatusTip(self.tr('Context sensitive help'))
+self,
-self.whatsThisAct.setWhatsThis(self.tr(
+"iconEditor_help_whats_this",
-"""<b>Display context sensitive help</b>"""
+)
-"""<p>In What's This? mode, the mouse cursor shows an arrow"""
+self.whatsThisAct.setStatusTip(self.tr("Context sensitive help"))
-""" with a question mark, and you can click on the interface"""
+self.whatsThisAct.setWhatsThis(
-""" elements to get a short description of what they do and"""
+self.tr(
-""" how to use them. In dialogs, this feature can be accessed"""
+"""<b>Display context sensitive help</b>"""
-""" using the context help button in the titlebar.</p>"""
+"""<p>In What's This? mode, the mouse cursor shows an arrow"""
-))
+""" with a question mark, and you can click on the interface"""
+""" elements to get a short description of what they do and"""
+""" how to use them. In dialogs, this feature can be accessed"""
+""" using the context help button in the titlebar.</p>"""
+)
+)
 self.whatsThisAct.triggered.connect(self.__whatsThis)
 self.__actions.append(self.whatsThisAct)
 def __initMenus(self):
 """
 Private method to create the menus.
 """
 mb = self.menuBar()
-menu = mb.addMenu(self.tr('&File'))
+menu = mb.addMenu(self.tr("&File"))
 menu.setTearOffEnabled(True)
 menu.addAction(self.newAct)
 menu.addAction(self.newWindowAct)
 menu.addAction(self.openAct)
 menu.addSeparator()
 if self.fromEric:
 menu.addAction(self.closeAllAct)
 else:
 menu.addSeparator()
 menu.addAction(self.exitAct)
 menu = mb.addMenu(self.tr("&Edit"))
 menu.setTearOffEnabled(True)
 menu.addAction(self.undoAct)
 menu.addAction(self.redoAct)
 menu.addSeparator()
 menu.addSeparator()
 menu.addAction(self.selectAllAct)
 menu.addSeparator()
 menu.addAction(self.resizeAct)
 menu.addAction(self.grayscaleAct)
-menu = mb.addMenu(self.tr('&View'))
+menu = mb.addMenu(self.tr("&View"))
 menu.setTearOffEnabled(True)
 menu.addAction(self.zoomInAct)
 menu.addAction(self.zoomResetAct)
 menu.addAction(self.zoomOutAct)
 menu.addSeparator()
 menu.addAction(self.showGridAct)
-menu = mb.addMenu(self.tr('&Tools'))
+menu = mb.addMenu(self.tr("&Tools"))
 menu.setTearOffEnabled(True)
 menu.addAction(self.drawPencilAct)
 menu.addAction(self.drawColorPickerAct)
 menu.addAction(self.drawRectangleAct)
 menu.addAction(self.drawFilledRectangleAct)
 menu.addAction(self.drawLineAct)
 menu.addAction(self.drawEraserAct)
 menu.addSeparator()
 menu.addAction(self.drawRectangleSelectionAct)
 menu.addAction(self.drawCircleSelectionAct)
 mb.addSeparator()
 menu = mb.addMenu(self.tr("&Help"))
 menu.addAction(self.aboutAct)
 menu.addAction(self.aboutQtAct)
 menu.addSeparator()
 menu.addAction(self.whatsThisAct)
 def __initToolbars(self):
 """
 Private method to create the toolbars.
 """
 filetb = self.addToolBar(self.tr("File"))
 filetb.addAction(self.saveAsAct)
 filetb.addSeparator()
 filetb.addAction(self.closeAct)
 if not self.fromEric:
 filetb.addAction(self.exitAct)
 edittb = self.addToolBar(self.tr("Edit"))
 edittb.setObjectName("EditToolBar")
 edittb.setIconSize(UI.Config.ToolBarIconSize)
 edittb.addAction(self.undoAct)
 edittb.addAction(self.redoAct)
 edittb.addAction(self.copyAct)
 edittb.addAction(self.pasteAct)
 edittb.addSeparator()
 edittb.addAction(self.resizeAct)
 edittb.addAction(self.grayscaleAct)
 viewtb = self.addToolBar(self.tr("View"))
 viewtb.setObjectName("ViewToolBar")
 viewtb.setIconSize(UI.Config.ToolBarIconSize)
 viewtb.addAction(self.showGridAct)
 toolstb = self.addToolBar(self.tr("Tools"))
 toolstb.setObjectName("ToolsToolBar")
 toolstb.setIconSize(UI.Config.ToolBarIconSize)
 toolstb.addAction(self.drawPencilAct)
 toolstb.addAction(self.drawColorPickerAct)
 toolstb.addAction(self.drawLineAct)
 toolstb.addAction(self.drawEraserAct)
 toolstb.addSeparator()
 toolstb.addAction(self.drawRectangleSelectionAct)
 toolstb.addAction(self.drawCircleSelectionAct)
 helptb = self.addToolBar(self.tr("Help"))
 helptb.setObjectName("HelpToolBar")
 helptb.setIconSize(UI.Config.ToolBarIconSize)
 helptb.addAction(self.whatsThisAct)
 def __createStatusBar(self):
 """
 Private method to initialize the status bar.
 """
 self.__statusBar = self.statusBar()
 self.__statusBar.setSizeGripEnabled(True)
 self.__sbSize = QLabel(self.__statusBar)
 self.__statusBar.addPermanentWidget(self.__sbSize)
-self.__sbSize.setWhatsThis(self.tr(
+self.__sbSize.setWhatsThis(
-"""<p>This part of the status bar displays the icon size.</p>"""
+self.tr("""<p>This part of the status bar displays the icon size.</p>""")
-))
+)
 self.__updateSize(*self.__editor.iconSize())
 self.__sbPos = QLabel(self.__statusBar)
 self.__statusBar.addPermanentWidget(self.__sbPos)
-self.__sbPos.setWhatsThis(self.tr(
+self.__sbPos.setWhatsThis(
-"""<p>This part of the status bar displays the cursor"""
+self.tr(
-""" position.</p>"""
+"""<p>This part of the status bar displays the cursor"""
-))
+""" position.</p>"""
+)
+)
 self.__updatePosition(0, 0)
 self.__zoomWidget = EricZoomWidget(
 UI.PixmapCache.getPixmap("zoomOut"),
 UI.PixmapCache.getPixmap("zoomIn"),
-UI.PixmapCache.getPixmap("zoomReset"), self)
+UI.PixmapCache.getPixmap("zoomReset"),
+self,
+)
 self.__zoomWidget.setMinimum(IconEditorGrid.ZoomMinimum)
 self.__zoomWidget.setMaximum(IconEditorGrid.ZoomMaximum)
 self.__zoomWidget.setDefault(IconEditorGrid.ZoomDefault)
 self.__zoomWidget.setSingleStep(IconEditorGrid.ZoomStep)
 self.__zoomWidget.setPercent(IconEditorGrid.ZoomPercent)
 self.__statusBar.addPermanentWidget(self.__zoomWidget)
 self.__zoomWidget.setValue(self.__editor.zoomFactor())
 self.__zoomWidget.valueChanged.connect(self.__editor.setZoomFactor)
 self.__editor.zoomChanged.connect(self.__zoomWidget.setValue)
 self.__updateZoom()
 def __createPaletteDock(self):
 """
 Private method to initialize the palette dock widget.
 """
 from .IconEditorPalette import IconEditorPalette
 self.__paletteDock = QDockWidget(self)
 self.__paletteDock.setObjectName("paletteDock")
 self.__paletteDock.setFeatures(
-QDockWidget.DockWidgetFeature.DockWidgetClosable |
+QDockWidget.DockWidgetFeature.DockWidgetClosable
-QDockWidget.DockWidgetFeature.DockWidgetMovable |
+| QDockWidget.DockWidgetFeature.DockWidgetMovable
-QDockWidget.DockWidgetFeature.DockWidgetFloatable
+| QDockWidget.DockWidgetFeature.DockWidgetFloatable
 )
 self.__paletteDock.setWindowTitle("Palette")
 self.__palette = IconEditorPalette()
 self.__paletteDock.setWidget(self.__palette)
-self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea,
+self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.__paletteDock)
-self.__paletteDock)
 def closeEvent(self, evt):
 """
 Protected event handler for the close event.
 @param evt the close event (QCloseEvent)
 <br />This event is simply accepted after the history has been
 saved and all window references have been deleted.
 """
 if self.__maybeSave():
 self.__editor.shutdown()
 state = self.saveState()
 Preferences.setIconEditor("IconEditorState", state)
 Preferences.setGeometry("IconEditorGeometry", self.saveGeometry())
 with contextlib.suppress(ValueError):
 if self.fromEric or len(self.__class__.windows) > 1:
-del self.__class__.windows[
+del self.__class__.windows[self.__class__.windows.index(self)]
-self.__class__.windows.index(self)]
 if not self.fromEric:
 Preferences.syncPreferences()
 evt.accept()
 self.editorClosed.emit()
 else:
 evt.ignore()
 def __newIcon(self):
 """
 Private slot to create a new icon.
 """
 if self.__maybeSave():
 self.__editor.editNew()
 self.__setCurrentFile("")
 self.__checkActions()
 def __newWindow(self):
 """
 Private slot called to open a new icon editor window.
 """
-ie = IconEditorWindow(parent=self.parent(), fromEric=self.fromEric,
+ie = IconEditorWindow(
-project=self.__project)
+parent=self.parent(), fromEric=self.fromEric, project=self.__project
+)
 ie.setRecentPaths(self.__lastOpenPath, self.__lastSavePath)
 ie.show()
 def __openIcon(self):
 """
 Private slot to open an icon file.
 """
 if self.__maybeSave():
 if (
-not self.__lastOpenPath and
+not self.__lastOpenPath
-self.__project is not None and
+and self.__project is not None
-self.__project.isOpen()
+and self.__project.isOpen()
 ):
 self.__lastOpenPath = self.__project.getProjectPath()
 fileName = EricFileDialog.getOpenFileNameAndFilter(
 self,
 self.tr("Open icon file"),
 self.__lastOpenPath,
 self.__inputFilter,
-self.__defaultFilter)[0]
+self.__defaultFilter,
+)[0]
 if fileName:
 self.__loadIconFile(fileName)
 self.__lastOpenPath = os.path.dirname(fileName)
 self.__checkActions()
 def __saveIcon(self):
 """
 Private slot to save the icon.
 @return flag indicating success (boolean)
 """
 if not self.__fileName:
 return self.__saveIconAs()
 else:
 return self.__saveIconFile(self.__fileName)
 def __saveIconAs(self):
 """
 Private slot to save the icon with a new name.
 @return flag indicating success (boolean)
 """
 if (
-not self.__lastSavePath and
+not self.__lastSavePath
-self.__project is not None and
+and self.__project is not None
-self.__project.isOpen()
+and self.__project.isOpen()
 ):
 self.__lastSavePath = self.__project.getProjectPath()
 if not self.__lastSavePath and self.__lastOpenPath:
 self.__lastSavePath = self.__lastOpenPath
 fileName, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
 self,
 self.tr("Save icon file"),
 self.__lastSavePath,
 self.__outputFilter,
 self.__defaultFilter,
-EricFileDialog.DontConfirmOverwrite)
+EricFileDialog.DontConfirmOverwrite,
+)
 if not fileName:
 return False
 fpath = pathlib.Path(fileName)
 if not fpath.suffix:
 ex = selectedFilter.split("(*")[1].split(")")[0]
 if ex:
 fpath = fpath.with_suffix(ex)
 if fpath.exists():
 res = EricMessageBox.yesNo(
 self,
 self.tr("Save icon file"),
-self.tr("<p>The file <b>{0}</b> already exists."
+self.tr(
-" Overwrite it?</p>").format(fpath),
+"<p>The file <b>{0}</b> already exists." " Overwrite it?</p>"
-icon=EricMessageBox.Warning)
+).format(fpath),
+icon=EricMessageBox.Warning,
+)
 if not res:
 return False
 self.__lastSavePath = str(fpath.parent)
 return self.__saveIconFile(str(fpath))
 def __closeAll(self):
 """
 Private slot to close all windows.
 """
 self.__closeOthers()
 self.close()
 def __closeOthers(self):
 """
 Private slot to close all other windows.
 """
 for win in self.__class__.windows[:]:
 if win != self:
 win.close()
 def __loadIconFile(self, fileName):
 """
 Private method to load an icon file.
 @param fileName name of the icon file to load (string).
 """
 img = QImage(fileName)
 if img.isNull():
 EricMessageBox.warning(
-self, self.tr("eric Icon Editor"),
+self,
-self.tr("Cannot read file '{0}'.").format(fileName))
+self.tr("eric Icon Editor"),
+self.tr("Cannot read file '{0}'.").format(fileName),
+)
 else:
 self.__editor.setIconImage(img, clearUndo=True)
 self.__setCurrentFile(fileName)
 def __saveIconFile(self, fileName):
 """
 Private method to save to the given file.
 @param fileName name of the file to save to (string)
 @return flag indicating success (boolean)
 """
 img = self.__editor.iconImage()
 res = img.save(fileName)
 if not res:
 EricMessageBox.warning(
-self, self.tr("eric Icon Editor"),
+self,
-self.tr("Cannot write file '{0}'.")
+self.tr("eric Icon Editor"),
-.format(fileName))
+self.tr("Cannot write file '{0}'.").format(fileName),
+)
 self.__checkActions()
 return False
 self.__editor.setDirty(False, setCleanState=True)
 self.__setCurrentFile(fileName)
 self.__statusBar.showMessage(self.tr("Icon saved"), 2000)
 self.__checkActions()
 return True
 def __setCurrentFile(self, fileName):
 """
 Private method to register the file name of the current file.
 @param fileName name of the file to register (string)
 """
 self.__fileName = fileName
 shownName = (
 self.__strippedName(self.__fileName)
-if self.__fileName else
+if self.__fileName
-self.tr("Untitled")
+else self.tr("Untitled")
 )
-self.setWindowTitle(self.tr("{0}[*] - {1}")
+self.setWindowTitle(
-.format(shownName, self.tr("Icon Editor")))
+self.tr("{0}[*] - {1}").format(shownName, self.tr("Icon Editor"))
+)
 self.setWindowModified(self.__editor.isDirty())
 def __strippedName(self, fullFileName):
 """
 Private method to return the filename part of the given path.
 @param fullFileName full pathname of the given file (string)
 @return filename part (string)
 """
 return pathlib.Path(fullFileName).name
 def __maybeSave(self):
 """
 Private method to ask the user to save the file, if it was modified.
 @return flag indicating, if it is ok to continue (boolean)
 """
 if self.__editor.isDirty():
 ret = EricMessageBox.okToClearData(
 self,
 self.tr("eric Icon Editor"),
 self.tr("""The icon image has unsaved changes."""),
-self.__saveIcon)
+self.__saveIcon,
+)
 if not ret:
 return False
 return True
 def setRecentPaths(self, openPath, savePath):
 """
 Public method to set the last open and save paths.
 @param openPath least recently used open path (string)
 @param savePath least recently used save path (string)
 """
 if openPath:
 self.__lastOpenPath = openPath
 if savePath:
 self.__lastSavePath = savePath
 def __checkActions(self):
 """
 Private slot to check some actions for their enable/disable status.
 """
 self.saveAct.setEnabled(self.__editor.isDirty())
 def __modificationChanged(self, m):
 """
 Private slot to handle the modificationChanged signal.
 @param m modification status
 """
 self.setWindowModified(m)
 self.__checkActions()
 def __updatePosition(self, x, y):
 """
 Private slot to show the current cursor position.
 @param x x-coordinate (integer)
 @param y y-coordinate (integer)
 """
 self.__sbPos.setText("X: {0:d} Y: {1:d}".format(x + 1, y + 1))
 def __updateSize(self, w, h):
 """
 Private slot to show the current icon size.
 @param w width of the icon (integer)
 @param h height of the icon (integer)
 """
 self.__sbSize.setText("Size: {0:d} x {1:d}".format(w, h))
 def __updateZoom(self):
 """
 Private slot to show the current zoom factor.
 """
 self.zoomOutAct.setEnabled(
-self.__editor.zoomFactor() > IconEditorGrid.ZoomMinimum)
+self.__editor.zoomFactor() > IconEditorGrid.ZoomMinimum
+)
 self.zoomInAct.setEnabled(
-self.__editor.zoomFactor() < IconEditorGrid.ZoomMaximum)
+self.__editor.zoomFactor() < IconEditorGrid.ZoomMaximum
+)
 def __zoomIn(self):
 """
 Private slot called to handle the zoom in action.
 """
 self.__editor.setZoomFactor(
-self.__editor.zoomFactor() + IconEditorGrid.ZoomStep)
+self.__editor.zoomFactor() + IconEditorGrid.ZoomStep
+)
 self.__updateZoom()
 def __zoomOut(self):
 """
 Private slot called to handle the zoom out action.
 """
 self.__editor.setZoomFactor(
-self.__editor.zoomFactor() - IconEditorGrid.ZoomStep)
+self.__editor.zoomFactor() - IconEditorGrid.ZoomStep
+)
 self.__updateZoom()
 def __zoomReset(self):
 """
 Private slot called to handle the zoom reset action.
 """
 self.__editor.setZoomFactor(IconEditorGrid.ZoomDefault)
 self.__updateZoom()
 def __about(self):
 """
 Private slot to show a little About message.
 """
 EricMessageBox.about(
-self, self.tr("About eric Icon Editor"),
+self,
-self.tr("The eric Icon Editor is a simple editor component"
+self.tr("About eric Icon Editor"),
-" to perform icon drawing tasks."))
+self.tr(
+"The eric Icon Editor is a simple editor component"
+" to perform icon drawing tasks."
+),
+)
 def __aboutQt(self):
 """
 Private slot to handle the About Qt dialog.
 """
 EricMessageBox.aboutQt(self, "eric Icon Editor")
 def __whatsThis(self):
 """
 Private slot called in to enter Whats This mode.
 """
 QWhatsThis.enterWhatsThisMode()
 def wheelEvent(self, evt):
 """
 Protected method to handle wheel events.
 @param evt reference to the wheel event (QWheelEvent)
 """
 if evt.modifiers() & Qt.KeyboardModifier.ControlModifier:
 delta = evt.angleDelta().y()
 if delta < 0:
 self.__zoomOut()
 elif delta > 0:
 self.__zoomIn()
 evt.accept()
 return
 super().wheelEvent(evt)
 def event(self, evt):
 """
 Public method handling events.
 @param evt reference to the event (QEvent)
 @return flag indicating, if the event was handled (boolean)
 """
 if evt.type() == QEvent.Type.Gesture:
 self.gestureEvent(evt)
 return True
 return super().event(evt)
 def gestureEvent(self, evt):
 """
 Protected method handling gesture events.
 @param evt reference to the gesture event (QGestureEvent
 """
 pinch = evt.gesture(Qt.GestureType.PinchGesture)
 if pinch:
 if pinch.state() == Qt.GestureState.GestureStarted:
 pinch.setTotalScaleFactor(self.__editor.zoomFactor() / 100.0)
 elif pinch.state() == Qt.GestureState.GestureUpdated:
-self.__editor.setZoomFactor(
+self.__editor.setZoomFactor(int(pinch.totalScaleFactor() * 100))
-int(pinch.totalScaleFactor() * 100))
 self.__updateZoom()
 evt.accept()

Mercurial Repositories > eric / file comparison

comparison: src/eric7/IconEditor/IconEditorWindow.py

src/eric7/IconEditor/IconEditorWindow.py