eric: comparison IconEditor/IconEditorWindow.py

-:0bc58cbb64b2
+:a81097a85889
 self.newAct.setStatusTip(self.trUtf8('Create a new icon'))
 self.newAct.setWhatsThis(self.trUtf8(
 """<b>New</b>"""
 """<p>This creates a new icon.</p>"""
 ))
-self.connect(self.newAct, SIGNAL('triggered()'), self.__newIcon)
+self.newAct.triggered.connect(self.__newIcon)
 self.__actions.append(self.newAct)
 self.newWindowAct = E5Action(self.trUtf8('New Window'),
 UI.PixmapCache.getIcon("newWindow.png"),
 self.trUtf8('New &Window'),
 self.newWindowAct.setStatusTip(self.trUtf8('Open a new icon editor window'))
 self.newWindowAct.setWhatsThis(self.trUtf8(
 """<b>New Window</b>"""
 """<p>This opens a new icon editor window.</p>"""
 ))
-self.connect(self.newWindowAct, SIGNAL('triggered()'), self.__newWindow)
+self.newWindowAct.triggered.connect(self.__newWindow)
 self.__actions.append(self.newWindowAct)
 self.openAct = E5Action(self.trUtf8('Open'),
 UI.PixmapCache.getIcon("open.png"),
 self.trUtf8('&Open...'),
 self.openAct.setWhatsThis(self.trUtf8(
 """<b>Open File</b>"""
 """<p>This opens a new icon file for editing."""
 """ It pops up a file selection dialog.</p>"""
 ))
-self.connect(self.openAct, SIGNAL('triggered()'), self.__openIcon)
+self.openAct.triggered.connect(self.__openIcon)
 self.__actions.append(self.openAct)
 self.saveAct = E5Action(self.trUtf8('Save'),
 UI.PixmapCache.getIcon("fileSave.png"),
 self.trUtf8('&Save'),
 self.saveAct.setStatusTip(self.trUtf8('Save the current icon'))
 self.saveAct.setWhatsThis(self.trUtf8(
 """<b>Save File</b>"""
 """<p>Save the contents of the icon editor window.</p>"""
 ))
-self.connect(self.saveAct, SIGNAL('triggered()'), self.__saveIcon)
+self.saveAct.triggered.connect(self.__saveIcon)
 self.__actions.append(self.saveAct)
 self.saveAsAct = E5Action(self.trUtf8('Save As'),
 UI.PixmapCache.getIcon("fileSaveAs.png"),
 self.trUtf8('Save &As...'),
 self.trUtf8('Save the current icon to a new file'))
 self.saveAsAct.setWhatsThis(self.trUtf8(
 """<b>Save As...</b>"""
 """<p>Saves the current icon to a new file.</p>"""
 ))
-self.connect(self.saveAsAct, SIGNAL('triggered()'), self.__saveIconAs)
+self.saveAsAct.triggered.connect(self.__saveIconAs)
 self.__actions.append(self.saveAsAct)
 self.closeAct = E5Action(self.trUtf8('Close'),
 UI.PixmapCache.getIcon("close.png"),
 self.trUtf8('&Close'),
 self.closeAct.setStatusTip(self.trUtf8('Close the current icon editor window'))
 self.closeAct.setWhatsThis(self.trUtf8(
 """<b>Close</b>"""
 """<p>Closes the current icon editor window.</p>"""
 ))
-self.connect(self.closeAct, SIGNAL('triggered()'), self.close)
+self.closeAct.triggered.connect(self.close)
 self.__actions.append(self.closeAct)
 self.closeAllAct = E5Action(self.trUtf8('Close All'),
 self.trUtf8('Close &All'),
 0, 0, self, 'iconEditor_file_close_all')
 self.closeAllAct.setStatusTip(self.trUtf8('Close all icon editor windows'))
 self.closeAllAct.setWhatsThis(self.trUtf8(
 """<b>Close All</b>"""
 """<p>Closes all icon editor windows except the first one.</p>"""
 ))
-self.connect(self.closeAllAct, SIGNAL('triggered()'), self.__closeAll)
+self.closeAllAct.triggered.connect(self.__closeAll)
 self.__actions.append(self.closeAllAct)
 self.exitAct = E5Action(self.trUtf8('Quit'),
 UI.PixmapCache.getIcon("exit.png"),
 self.trUtf8('&Quit'),
 self.exitAct.setWhatsThis(self.trUtf8(
 """<b>Quit</b>"""
 """<p>Quit the icon editor.</p>"""
 ))
 if self.fromEric:
-self.connect(self.exitAct, SIGNAL('triggered()'), self.close)
+self.exitAct.triggered.connect(self.close)
 else:
 self.connect(self.exitAct, SIGNAL('triggered()'),
 qApp, SLOT('closeAllWindows()'))
 self.__actions.append(self.exitAct)
 self.undoAct.setStatusTip(self.trUtf8('Undo the last change'))
 self.undoAct.setWhatsThis(self.trUtf8(\
 """<b>Undo</b>"""
 """<p>Undo the last change done.</p>"""
 ))
-self.connect(self.undoAct, SIGNAL('triggered()'), self.__editor.editUndo)
+self.undoAct.triggered.connect(self.__editor.editUndo)
 self.__actions.append(self.undoAct)
 self.redoAct = E5Action(self.trUtf8('Redo'),
 UI.PixmapCache.getIcon("editRedo.png"),
 self.trUtf8('&Redo'),
 self.redoAct.setStatusTip(self.trUtf8('Redo the last change'))
 self.redoAct.setWhatsThis(self.trUtf8(\
 """<b>Redo</b>"""
 """<p>Redo the last change done.</p>"""
 ))
-self.connect(self.redoAct, SIGNAL('triggered()'), self.__editor.editRedo)
+self.redoAct.triggered.connect(self.__editor.editRedo)
 self.__actions.append(self.redoAct)
 self.cutAct = E5Action(self.trUtf8('Cut'),
 UI.PixmapCache.getIcon("editCut.png"),
 self.trUtf8('Cu&t'),
 self.cutAct.setStatusTip(self.trUtf8('Cut the selection'))
 self.cutAct.setWhatsThis(self.trUtf8(\
 """<b>Cut</b>"""
 """<p>Cut the selected image area to the clipboard.</p>"""
 ))
-self.connect(self.cutAct, SIGNAL('triggered()'), self.__editor.editCut)
+self.cutAct.triggered.connect(self.__editor.editCut)
 self.__actions.append(self.cutAct)
 self.copyAct = E5Action(self.trUtf8('Copy'),
 UI.PixmapCache.getIcon("editCopy.png"),
 self.trUtf8('&Copy'),
 self.copyAct.setStatusTip(self.trUtf8('Copy the selection'))
 self.copyAct.setWhatsThis(self.trUtf8(\
 """<b>Copy</b>"""
 """<p>Copy the selected image area to the clipboard.</p>"""
 ))
-self.connect(self.copyAct, SIGNAL('triggered()'), self.__editor.editCopy)
+self.copyAct.triggered.connect(self.__editor.editCopy)
 self.__actions.append(self.copyAct)
 self.pasteAct = E5Action(self.trUtf8('Paste'),
 UI.PixmapCache.getIcon("editPaste.png"),
 self.trUtf8('&Paste'),
 self.pasteAct.setStatusTip(self.trUtf8('Paste the clipboard image'))
 self.pasteAct.setWhatsThis(self.trUtf8(\
 """<b>Paste</b>"""
 """<p>Paste the clipboard image.</p>"""
 ))
-self.connect(self.pasteAct, SIGNAL('triggered()'), self.__editor.editPaste)
+self.pasteAct.triggered.connect(self.__editor.editPaste)
 self.__actions.append(self.pasteAct)
 self.pasteNewAct = E5Action(self.trUtf8('Paste as New'),
 self.trUtf8('Paste as &New'),
 0, 0, self, 'iconEditor_edit_paste_as_new')
 'Paste the clipboard image replacing the current one'))
 self.pasteNewAct.setWhatsThis(self.trUtf8(\
 """<b>Paste as New</b>"""
 """<p>Paste the clipboard image replacing the current one.</p>"""
 ))
-self.connect(self.pasteNewAct, SIGNAL('triggered()'), self.__editor.editPasteAsNew)
+self.pasteNewAct.triggered.connect(self.__editor.editPasteAsNew)
 self.__actions.append(self.pasteNewAct)
 self.deleteAct = E5Action(self.trUtf8('Clear'),
 UI.PixmapCache.getIcon("editDelete.png"),
 self.trUtf8('Cl&ear'),
 self.deleteAct.setStatusTip(self.trUtf8('Clear the icon image'))
 self.deleteAct.setWhatsThis(self.trUtf8(\
 """<b>Clear</b>"""
 """<p>Clear the icon image and set it to be completely transparent.</p>"""
 ))
-self.connect(self.deleteAct, SIGNAL('triggered()'), self.__editor.editClear)
+self.deleteAct.triggered.connect(self.__editor.editClear)
 self.__actions.append(self.deleteAct)
 self.selectAllAct = E5Action(self.trUtf8('Select All'),
 self.trUtf8('&Select All'),
 QKeySequence(self.trUtf8("Ctrl+A", "Edit|Select All")),
 self.selectAllAct.setStatusTip(self.trUtf8('Select the complete icon image'))
 self.selectAllAct.setWhatsThis(self.trUtf8(\
 """<b>Select All</b>"""
 """<p>Selects the complete icon image.</p>"""
 ))
-self.connect(self.selectAllAct, SIGNAL('triggered()'), self.__editor.editSelectAll)
+self.selectAllAct.triggered.connect(self.__editor.editSelectAll)
 self.__actions.append(self.selectAllAct)
 self.resizeAct = E5Action(self.trUtf8('Change Size'),
 UI.PixmapCache.getIcon("transformResize.png"),
 self.trUtf8('Change Si&ze...'),
 self.resizeAct.setStatusTip(self.trUtf8('Change the icon size'))
 self.resizeAct.setWhatsThis(self.trUtf8(\
 """<b>Change Size...</b>"""
 """<p>Changes the icon size.</p>"""
 ))
-self.connect(self.resizeAct, SIGNAL('triggered()'), self.__editor.editResize)
+self.resizeAct.triggered.connect(self.__editor.editResize)
 self.__actions.append(self.resizeAct)
 self.grayscaleAct = E5Action(self.trUtf8('Grayscale'),
 UI.PixmapCache.getIcon("grayscale.png"),
 self.trUtf8('&Grayscale'),
 self.grayscaleAct.setStatusTip(self.trUtf8('Change the icon to grayscale'))
 self.grayscaleAct.setWhatsThis(self.trUtf8(\
 """<b>Grayscale</b>"""
 """<p>Changes the icon to grayscale.</p>"""
 ))
-self.connect(self.grayscaleAct, SIGNAL('triggered()'), self.__editor.grayScale)
+self.grayscaleAct.triggered.connect(self.__editor.grayScale)
 self.__actions.append(self.grayscaleAct)
 self.redoAct.setEnabled(False)
 self.connect(self.__editor, SIGNAL("canRedoChanged(bool)"),
 self.redoAct, SLOT("setEnabled(bool)"))
 self.zoomInAct.setStatusTip(self.trUtf8('Zoom in on the icon'))
 self.zoomInAct.setWhatsThis(self.trUtf8(
 """<b>Zoom in</b>"""
 """<p>Zoom in on the icon. This makes the grid bigger.</p>"""
 ))
-self.connect(self.zoomInAct, SIGNAL('triggered()'), self.__zoomIn)
+self.zoomInAct.triggered.connect(self.__zoomIn)
 self.__actions.append(self.zoomInAct)
 self.zoomOutAct = E5Action(self.trUtf8('Zoom out'),
 UI.PixmapCache.getIcon("zoomOut.png"),
 self.trUtf8('Zoom &out'),
 self.zoomOutAct.setStatusTip(self.trUtf8('Zoom out on the icon'))
 self.zoomOutAct.setWhatsThis(self.trUtf8(
 """<b>Zoom out</b>"""
 """<p>Zoom out on the icon. This makes the grid smaller.</p>"""
 ))
-self.connect(self.zoomOutAct, SIGNAL('triggered()'), self.__zoomOut)
+self.zoomOutAct.triggered.connect(self.__zoomOut)
 self.__actions.append(self.zoomOutAct)
 self.zoomResetAct = E5Action(self.trUtf8('Zoom reset'),
 UI.PixmapCache.getIcon("zoomReset.png"),
 self.trUtf8('Zoom &reset'),
 self.zoomResetAct.setWhatsThis(self.trUtf8(
 """<b>Zoom reset</b>"""
 """<p>Reset the zoom of the icon. """
 """This sets the zoom factor to 100%.</p>"""
 ))
-self.connect(self.zoomResetAct, SIGNAL('triggered()'), self.__zoomReset)
+self.zoomResetAct.triggered.connect(self.__zoomReset)
 self.__actions.append(self.zoomResetAct)
 self.zoomToAct = E5Action(self.trUtf8('Zoom'),
 UI.PixmapCache.getIcon("zoomTo.png"),
 self.trUtf8('&Zoom...'),
 self.zoomToAct.setWhatsThis(self.trUtf8(
 """<b>Zoom</b>"""
 """<p>Zoom the icon. This opens a dialog where the"""
 """ desired zoom factor can be entered.</p>"""
 ))
-self.connect(self.zoomToAct, SIGNAL('triggered()'), self.__zoom)
+self.zoomToAct.triggered.connect(self.__zoom)
 self.__actions.append(self.zoomToAct)
 self.showGridAct = E5Action(self.trUtf8('Show Grid'),
 UI.PixmapCache.getIcon("grid.png"),
 self.trUtf8('Show &Grid'),
 """<b>Free hand</b>"""
 """<p>Draws non linear lines.</p>"""
 ))
 self.drawPencilAct.setCheckable(True)
 self.esm.setMapping(self.drawPencilAct, IconEditorGrid.Pencil)
-self.connect(self.drawPencilAct, SIGNAL('triggered()'),
+self.drawPencilAct.triggered.connect(self.esm.map)
-self.esm, SLOT('map()'))
 self.__actions.append(self.drawPencilAct)
 self.drawColorPickerAct = E5Action(self.trUtf8('Color Picker'),
 UI.PixmapCache.getIcon("colorPicker.png"),
 self.trUtf8('&Color Picker'),
 """<p>The color of the pixel clicked on will become """
 """the current draw color.</p>"""
 ))
 self.drawColorPickerAct.setCheckable(True)
 self.esm.setMapping(self.drawColorPickerAct, IconEditorGrid.ColorPicker)
-self.connect(self.drawColorPickerAct, SIGNAL('triggered()'),
+self.drawColorPickerAct.triggered.connect(self.esm.map)
-self.esm, SLOT('map()'))
 self.__actions.append(self.drawColorPickerAct)
 self.drawRectangleAct = E5Action(self.trUtf8('Rectangle'),
 UI.PixmapCache.getIcon("drawRectangle.png"),
 self.trUtf8('&Rectangle'),
 """<b>Rectangle</b>"""
 """<p>Draw a rectangle.</p>"""
 ))
 self.drawRectangleAct.setCheckable(True)
 self.esm.setMapping(self.drawRectangleAct, IconEditorGrid.Rectangle)
-self.connect(self.drawRectangleAct, SIGNAL('triggered()'),
+self.drawRectangleAct.triggered.connect(self.esm.map)
-self.esm, SLOT('map()'))
 self.__actions.append(self.drawRectangleAct)
 self.drawFilledRectangleAct = E5Action(self.trUtf8('Filled Rectangle'),
 UI.PixmapCache.getIcon("drawRectangleFilled.png"),
 self.trUtf8('F&illed Rectangle'),
 """<b>Filled Rectangle</b>"""
 """<p>Draw a filled rectangle.</p>"""
 ))
 self.drawFilledRectangleAct.setCheckable(True)
 self.esm.setMapping(self.drawFilledRectangleAct, IconEditorGrid.FilledRectangle)
-self.connect(self.drawFilledRectangleAct, SIGNAL('triggered()'),
+self.drawFilledRectangleAct.triggered.connect(self.esm.map)
-self.esm, SLOT('map()'))
 self.__actions.append(self.drawFilledRectangleAct)
 self.drawCircleAct = E5Action(self.trUtf8('Circle'),
 UI.PixmapCache.getIcon("drawCircle.png"),
 self.trUtf8('Circle'),
 """<b>Circle</b>"""
 """<p>Draw a circle.</p>"""
 ))
 self.drawCircleAct.setCheckable(True)
 self.esm.setMapping(self.drawCircleAct, IconEditorGrid.Circle)
-self.connect(self.drawCircleAct, SIGNAL('triggered()'),
+self.drawCircleAct.triggered.connect(self.esm.map)
-self.esm, SLOT('map()'))
 self.__actions.append(self.drawCircleAct)
 self.drawFilledCircleAct = E5Action(self.trUtf8('Filled Circle'),
 UI.PixmapCache.getIcon("drawCircleFilled.png"),
 self.trUtf8('Fille&d Circle'),
 """<b>Filled Circle</b>"""
 """<p>Draw a filled circle.</p>"""
 ))
 self.drawFilledCircleAct.setCheckable(True)
 self.esm.setMapping(self.drawFilledCircleAct, IconEditorGrid.FilledCircle)
-self.connect(self.drawFilledCircleAct, SIGNAL('triggered()'),
+self.drawFilledCircleAct.triggered.connect(self.esm.map)
-self.esm, SLOT('map()'))
 self.__actions.append(self.drawFilledCircleAct)
 self.drawEllipseAct = E5Action(self.trUtf8('Ellipse'),
 UI.PixmapCache.getIcon("drawEllipse.png"),
 self.trUtf8('&Ellipse'),
 """<b>Ellipse</b>"""
 """<p>Draw an ellipse.</p>"""
 ))
 self.drawEllipseAct.setCheckable(True)
 self.esm.setMapping(self.drawEllipseAct, IconEditorGrid.Ellipse)
-self.connect(self.drawEllipseAct, SIGNAL('triggered()'),
+self.drawEllipseAct.triggered.connect(self.esm.map)
-self.esm, SLOT('map()'))
 self.__actions.append(self.drawEllipseAct)
 self.drawFilledEllipseAct = E5Action(self.trUtf8('Filled Ellipse'),
 UI.PixmapCache.getIcon("drawEllipseFilled.png"),
 self.trUtf8('Fille&d Elli&pse'),
 """<b>Filled Ellipse</b>"""
 """<p>Draw a filled ellipse.</p>"""
 ))
 self.drawFilledEllipseAct.setCheckable(True)
 self.esm.setMapping(self.drawFilledEllipseAct, IconEditorGrid.FilledEllipse)
-self.connect(self.drawFilledEllipseAct, SIGNAL('triggered()'),
+self.drawFilledEllipseAct.triggered.connect(self.esm.map)
-self.esm, SLOT('map()'))
 self.__actions.append(self.drawFilledEllipseAct)
 self.drawFloodFillAct = E5Action(self.trUtf8('Flood Fill'),
 UI.PixmapCache.getIcon("drawFill.png"),
 self.trUtf8('Fl&ood Fill'),
 """<p>Fill adjoining pixels with the same color with """
 """the current color.</p>"""
 ))
 self.drawFloodFillAct.setCheckable(True)
 self.esm.setMapping(self.drawFloodFillAct, IconEditorGrid.Fill)
-self.connect(self.drawFloodFillAct, SIGNAL('triggered()'),
+self.drawFloodFillAct.triggered.connect(self.esm.map)
-self.esm, SLOT('map()'))
 self.__actions.append(self.drawFloodFillAct)
 self.drawLineAct = E5Action(self.trUtf8('Line'),
 UI.PixmapCache.getIcon("drawLine.png"),
 self.trUtf8('&Line'),
 """<b>Line</b>"""
 """<p>Draw a line.</p>"""
 ))
 self.drawLineAct.setCheckable(True)
 self.esm.setMapping(self.drawLineAct, IconEditorGrid.Line)
-self.connect(self.drawLineAct, SIGNAL('triggered()'),
+self.drawLineAct.triggered.connect(self.esm.map)
-self.esm, SLOT('map()'))
 self.__actions.append(self.drawLineAct)
 self.drawEraserAct = E5Action(self.trUtf8('Eraser (Transparent)'),
 UI.PixmapCache.getIcon("drawEraser.png"),
 self.trUtf8('Eraser (&Transparent)'),
 """<b>Eraser (Transparent)</b>"""
 """<p>Erase pixels by setting them to transparent.</p>"""
 ))
 self.drawEraserAct.setCheckable(True)
 self.esm.setMapping(self.drawEraserAct, IconEditorGrid.Rubber)
-self.connect(self.drawEraserAct, SIGNAL('triggered()'),
+self.drawEraserAct.triggered.connect(self.esm.map)
-self.esm, SLOT('map()'))
 self.__actions.append(self.drawEraserAct)
 self.drawRectangleSelectionAct = E5Action(self.trUtf8('Rectangular Selection'),
 UI.PixmapCache.getIcon("selectRectangle.png"),
 self.trUtf8('Rect&angular Selection'),
 """<p>Select a rectangular section of the icon using the mouse.</p>"""
 ))
 self.drawRectangleSelectionAct.setCheckable(True)
 self.esm.setMapping(self.drawRectangleSelectionAct,
 IconEditorGrid.RectangleSelection)
-self.connect(self.drawRectangleSelectionAct, SIGNAL('triggered()'),
+self.drawRectangleSelectionAct.triggered.connect(self.esm.map)
-self.esm, SLOT('map()'))
 self.__actions.append(self.drawRectangleSelectionAct)
 self.drawCircleSelectionAct = E5Action(self.trUtf8('Circular Selection'),
 UI.PixmapCache.getIcon("selectCircle.png"),
 self.trUtf8('Rect&angular Selection'),
 """<p>Select a circular section of the icon using the mouse.</p>"""
 ))
 self.drawCircleSelectionAct.setCheckable(True)
 self.esm.setMapping(self.drawCircleSelectionAct,
 IconEditorGrid.CircleSelection)
-self.connect(self.drawCircleSelectionAct, SIGNAL('triggered()'),
+self.drawCircleSelectionAct.triggered.connect(self.esm.map)
-self.esm, SLOT('map()'))
 self.__actions.append(self.drawCircleSelectionAct)
 self.drawPencilAct.setChecked(True)
 def __initHelpActions(self):
 0, 0, self, 'iconEditor_help_about')
 self.aboutAct.setStatusTip(self.trUtf8('Display information about this software'))
 self.aboutAct.setWhatsThis(self.trUtf8(
 """<b>About</b>"""
 """<p>Display some information about this software.</p>"""))
-self.connect(self.aboutAct, SIGNAL('triggered()'), self.__about)
+self.aboutAct.triggered.connect(self.__about)
 self.__actions.append(self.aboutAct)
 self.aboutQtAct = E5Action(self.trUtf8('About Qt'),
 self.trUtf8('About &Qt'),
 0, 0, self, 'iconEditor_help_about_qt')
 self.trUtf8('Display information about the Qt toolkit'))
 self.aboutQtAct.setWhatsThis(self.trUtf8(
 """<b>About Qt</b>"""
 """<p>Display some information about the Qt toolkit.</p>"""
 ))
-self.connect(self.aboutQtAct, SIGNAL('triggered()'), self.__aboutQt)
+self.aboutQtAct.triggered.connect(self.__aboutQt)
 self.__actions.append(self.aboutQtAct)
 self.whatsThisAct = E5Action(self.trUtf8('What\'s This?'),
 UI.PixmapCache.getIcon("whatsThis.png"),
 self.trUtf8('&What\'s This?'),
 """ 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.connect(self.whatsThisAct, SIGNAL('triggered()'), self.__whatsThis)
+self.whatsThisAct.triggered.connect(self.__whatsThis)
 self.__actions.append(self.whatsThisAct)
 def __initMenus(self):
 """
 Private method to create the menus.

Mercurial Repositories > eric / file comparison

comparison: IconEditor/IconEditorWindow.py

IconEditor/IconEditorWindow.py