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

-:3733e2b23cf7
+:a071d4065202
 def __init__(self, grid, text, oldImage, parent=None):
 """
 Constructor
-@param grid reference to the icon editor grid (IconEditorGrid)
+@param grid reference to the icon editor grid
-@param text text for the undo command (string)
+@type IconEditorGrid
+@param text text for the undo command
+@type str
 @param oldImage copy of the icon before the changes were applied
-(QImage)
+@type QImage
-@param parent reference to the parent command (QUndoCommand)
+@param parent reference to the parent command
+@type QUndoCommand
 """
 super().__init__(text, parent)
 self.__grid = grid
 self.__imageBefore = QImage(oldImage)
 def setAfterImage(self, image):
 """
 Public method to set the image after the changes were applied.
-@param image copy of the icon after the changes were applied (QImage)
+@param image copy of the icon after the changes were applied
+@type QImage
 """
 self.__imageAfter = QImage(image)
 def undo(self):
 """
 def __init__(self, parent=None):
 """
 Constructor
-@param parent reference to the parent widget (QWidget)
+@param parent reference to the parent widget
+@type QWidget
 """
 super().__init__(parent)
 self.setAttribute(Qt.WidgetAttribute.WA_StaticContents)
 self.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
 def isDirty(self):
 """
 Public method to check the dirty status.
-@return flag indicating a modified status (boolean)
+@return flag indicating a modified status
+@rtype bool
 """
 return self.__dirty
 def setDirty(self, dirty, setCleanState=False):
 """
 Public slot to set the dirty flag.
-@param dirty flag indicating the new modification status (boolean)
+@param dirty flag indicating the new modification status
+@type bool
 @param setCleanState flag indicating to set the undo stack to clean
-(boolean)
+@type bool
 """
 self.__dirty = dirty
 self.imageChanged.emit(dirty)
 if not dirty and setCleanState:
 def sizeHint(self):
 """
 Public method to report the size hint.
-@return size hint (QSize)
+@return size hint
+@rtype QSize
 """
 size = self.__zoom * self.__image.size()
 if self.__zoom >= 3 and self.__gridEnabled:
 size += QSize(1, 1)
 return size
 def setPenColor(self, newColor):
 """
 Public method to set the drawing color.
-@param newColor reference to the new color (QColor)
+@param newColor reference to the new color
+@type QColor
 """
 self.__curColor = QColor(newColor)
 self.colorChanged.emit(QColor(newColor))
 def penColor(self):
 """
 Public method to get the current drawing color.
-@return current drawing color (QColor)
+@return current drawing color
+@rtype QColor
 """
 return QColor(self.__curColor)
 def setCompositingMode(self, mode):
 """
 Public method to set the compositing mode.
-@param mode compositing mode to set (QPainter.CompositionMode)
+@param mode compositing mode to set
+@type QPainter.CompositionMode
 """
 self.__compositingMode = mode
 def compositingMode(self):
 """
 Public method to get the compositing mode.
-@return compositing mode (QPainter.CompositionMode)
+@return compositing mode
+@rtype QPainter.CompositionMode
 """
 return self.__compositingMode
 def setTool(self, tool):
 """
 def setIconImage(self, newImage, undoRedo=False, clearUndo=False):
 """
 Public method to set a new icon image.
-@param newImage reference to the new image (QImage)
+@param newImage reference to the new image
-@param undoRedo flag indicating an undo or redo operation (boolean)
+@type QImage
-@param clearUndo flag indicating to clear the undo stack (boolean)
+@param undoRedo flag indicating an undo or redo operation
+@type bool
+@param clearUndo flag indicating to clear the undo stack
+@type bool
 """
 if newImage != self.__image:
 self.__image = newImage.convertToFormat(QImage.Format.Format_ARGB32)
 self.update()
 self.updateGeometry()
 def iconImage(self):
 """
 Public method to get a copy of the icon image.
-@return copy of the icon image (QImage)
+@return copy of the icon image
+@rtype QImage
 """
 return QImage(self.__image)
 def iconSize(self):
 """
 Public method to get the size of the icon.
-@return width and height of the image as a tuple (integer, integer)
+@return width and height of the image as a tuple
+@rtype tuple of (int, int)
 """
 return self.__image.width(), self.__image.height()
 def setZoomFactor(self, newZoom):
 """
 Public method to set the zoom factor in percent.
-@param newZoom zoom factor (integer >= 100)
+@param newZoom zoom factor (>= 100)
+@type int
 """
 newZoom = max(100, newZoom)  # must not be less than 100
 if newZoom != self.__zoom:
 self.__zoom = newZoom // 100
 self.update()
 def zoomFactor(self):
 """
 Public method to get the current zoom factor in percent.
-@return zoom factor (integer)
+@return zoom factor
+@rtype int
 """
 return self.__zoom * 100
 def setGridEnabled(self, enable):
 """
 Public method to enable the display of grid lines.
-@param enable enabled status of the grid lines (boolean)
+@param enable enabled status of the grid lines
+@type bool
 """
 if enable != self.__gridEnabled:
 self.__gridEnabled = enable
 self.update()
 def isGridEnabled(self):
 """
 Public method to get the grid lines status.
-@return enabled status of the grid lines (boolean)
+@return enabled status of the grid lines
+@rtype bool
 """
 return self.__gridEnabled
 def paintEvent(self, evt):
 """
 Protected method called to repaint some of the widget.
-@param evt reference to the paint event object (QPaintEvent)
+@param evt reference to the paint event object
+@type QPaintEvent
 """
 painter = QPainter(self)
 if self.__zoom >= 3 and self.__gridEnabled:
 if ericApp().usesDarkPalette():
 def __pixelRect(self, i, j):
 """
 Private method to determine the rectangle for a given pixel coordinate.
-@param i x-coordinate of the pixel in the image (integer)
+@param i x-coordinate of the pixel in the image
-@param j y-coordinate of the pixel in the image (integer)
+@type int
-@return rectangle for the given pixel coordinates (QRect)
+@param j y-coordinate of the pixel in the image
+@type int
+@return rectangle for the given pixel coordinates
+@rtype QRect
 """
 if self.__zoom >= 3 and self.__gridEnabled:
 return QRect(
 self.__zoom * i + 1,
 self.__zoom * j + 1,
 def mousePressEvent(self, evt):
 """
 Protected method to handle mouse button press events.
-@param evt reference to the mouse event object (QMouseEvent)
+@param evt reference to the mouse event object
+@type QMouseEvent
 """
 if evt.button() == Qt.MouseButton.LeftButton:
 if self.__isPasting:
 self.__isPasting = False
 self.editPaste(True)
 def mouseMoveEvent(self, evt):
 """
 Protected method to handle mouse move events.
-@param evt reference to the mouse event object (QMouseEvent)
+@param evt reference to the mouse event object
+@type QMouseEvent
 """
 self.positionChanged.emit(*self.__imageCoordinates(evt.position().toPoint()))
 if self.__isPasting and not (evt.buttons() & Qt.MouseButton.LeftButton):
 self.__drawPasteRect(evt.position().toPoint())
 def mouseReleaseEvent(self, evt):
 """
 Protected method to handle mouse button release events.
-@param evt reference to the mouse event object (QMouseEvent)
+@param evt reference to the mouse event object
+@type QMouseEvent
 """
 if evt.button() == Qt.MouseButton.LeftButton:
 if (
 self.__curTool in [IconEditorTool.PENCIL, IconEditorTool.RUBBER]
 and self.__currentUndoCmd
 def __setImagePixel(self, pos, opaque):
 """
 Private slot to set or erase a pixel.
-@param pos position of the pixel in the widget (QPoint)
+@param pos position of the pixel in the widget
-@param opaque flag indicating a set operation (boolean)
+@type QPoint
+@param opaque flag indicating a set operation
+@type bool
 """
 i, j = self.__imageCoordinates(pos)
 if self.__image.rect().contains(i, j) and (i, j) != self.__lastPos:
 if opaque:
 def __imageCoordinates(self, pos):
 """
 Private method to convert from widget to image coordinates.
-@param pos widget coordinate (QPoint)
+@param pos widget coordinate
-@return tuple with the image coordinates (tuple of two integers)
+@type QPoint
+@return tuple with the image coordinates
+@rtype tuple of (int, int)
 """
 i = pos.x() // self.__zoom
 j = pos.y() // self.__zoom
 return i, j
 def __drawPasteRect(self, pos):
 """
 Private slot to draw a rectangle for signaling a paste operation.
-@param pos widget position of the paste rectangle (QPoint)
+@param pos widget position of the paste rectangle
+@type QPoint
 """
 self.__markImage.fill(self.NoMarkColor.rgba())
 if self.__pasteRect.isValid():
 self.__updateImageRect(
 self.__pasteRect.topLeft(),
 def __drawTool(self, pos, mark):
 """
 Private method to perform a draw operation depending of the current
 tool.
-@param pos widget coordinate to perform the draw operation at (QPoint)
+@param pos widget coordinate to perform the draw operation at
-@param mark flag indicating a mark operation (boolean)
+@type QPoint
-@return flag indicating a successful draw (boolean)
+@param mark flag indicating a mark operation
+@type bool
+@return flag indicating a successful draw
+@rtype bool
 """
 self.__unMark()
 if mark:
 self.__endPos = QPoint(pos)
 def __drawFlood(self, i, j, oldColor, doUpdate=True):
 """
 Private method to perform a flood fill operation.
-@param i x-value in image coordinates (integer)
+@param i x-value in image coordinates
-@param j y-value in image coordinates (integer)
+@type int
-@param oldColor reference to the color at position i, j (QColor)
+@param j y-value in image coordinates
-@param doUpdate flag indicating an update is requested (boolean)
+@type int
+@param oldColor reference to the color at position i, j
+@type QColor
+@param doUpdate flag indicating an update is requested
 (used for speed optimizations)
+@type bool
 """
 if (
 not self.__image.rect().contains(i, j)
 or self.__image.pixel(i, j) != oldColor.rgba()
 or self.__image.pixel(i, j) == self.penColor().rgba()
 def __updateRect(self, pos1, pos2):
 """
 Private slot to update parts of the widget.
 @param pos1 top, left position for the update in widget coordinates
-(QPoint)
+@type QPoint
 @param pos2 bottom, right position for the update in widget
-coordinates (QPoint)
+coordinates
+@type QPoint
 """
 self.__updateImageRect(
 QPoint(*self.__imageCoordinates(pos1)),
 QPoint(*self.__imageCoordinates(pos2)),
 )
 def __updateImageRect(self, ipos1, ipos2):
 """
 Private slot to update parts of the widget.
 @param ipos1 top, left position for the update in image coordinates
-(QPoint)
+@type QPoint
 @param ipos2 bottom, right position for the update in image
-coordinates (QPoint)
+coordinates
+@type QPoint
 """
 r1 = self.__pixelRect(ipos1.x(), ipos1.y())
 r2 = self.__pixelRect(ipos2.x(), ipos2.y())
 left = min(r1.x(), r2.x())
 def __isMarked(self, i, j):
 """
 Private method to check, if a pixel is marked.
-@param i x-value in image coordinates (integer)
+@param i x-value in image coordinates
-@param j y-value in image coordinates (integer)
+@type int
-@return flag indicating a marked pixel (boolean)
+@param j y-value in image coordinates
+@type int
+@return flag indicating a marked pixel
+@rtype bool
 """
 return self.__markImage.pixel(i, j) == self.MarkColor.rgba()
 def __updatePreviewPixmap(self):
 """
 def previewPixmap(self):
 """
 Public method to generate a preview pixmap.
-@return preview pixmap (QPixmap)
+@return preview pixmap
+@rtype QPixmap
 """
 p = QPixmap.fromImage(self.__image)
 return p
 def __checkClipboard(self):
 def canPaste(self):
 """
 Public slot to check the availability of the paste operation.
-@return flag indicating availability of paste (boolean)
+@return flag indicating availability of paste
+@rtype bool
 """
 return self.__clipboardImageAvailable
 def __clipboardImage(self):
 """
 Private method to get an image from the clipboard.
 @return tuple with the image (QImage) and a flag indicating a
-valid image (boolean)
+valid image
+@rtype bool
 """
 img = QApplication.clipboard().image()
 ok = not img.isNull()
 if ok:
 img = img.convertToFormat(QImage.Format.Format_ARGB32)
 def __getSelectionImage(self, cut):
 """
 Private method to get an image from the selection.
-@param cut flag indicating to cut the selection (boolean)
+@param cut flag indicating to cut the selection
-@return image of the selection (QImage)
+@type bool
+@return image of the selection
+@rtype QImage
 """
 if cut:
 cmd = IconEditCommand(self, self.tr("Cut Selection"), self.__image)
 img = QImage(self.__selRect.size(), QImage.Format.Format_ARGB32)
 def editPaste(self, pasting=False):
 """
 Public slot to paste an image from the clipboard.
 @param pasting flag indicating part two of the paste operation
-(boolean)
+@type bool
 """
 img, ok = self.__clipboardImage()
 if ok:
 if (
 img.width() > self.__image.width()
 def canUndo(self):
 """
 Public method to return the undo status.
-@return flag indicating the availability of undo (boolean)
+@return flag indicating the availability of undo
+@rtype bool
 """
 return self.__undoStack.canUndo()
 def canRedo(self):
 """
 Public method to return the redo status.
-@return flag indicating the availability of redo (boolean)
+@return flag indicating the availability of redo
+@rtype bool
 """
 return self.__undoStack.canRedo()
 def __cleanChanged(self, clean):
 """
 Private slot to handle the undo stack clean state change.
-@param clean flag indicating the clean state (boolean)
+@param clean flag indicating the clean state
+@type bool
 """
 self.setDirty(not clean)
 def shutdown(self):
 """
 def isSelectionAvailable(self):
 """
 Public method to check the availability of a selection.
-@return flag indicating the availability of a selection (boolean)
+@return flag indicating the availability of a selection
+@rtype bool
 """
 return self.__selectionAvailable

Mercurial Repositories > eric / file comparison

comparison: src/eric7/IconEditor/IconEditorGrid.py

src/eric7/IconEditor/IconEditorGrid.py