eric: comparison IconEditor/IconEditorGrid.py

-:9986ec0e559a
+:10516539f238
 """
 from __future__ import unicode_literals    # __IGNORE_WARNING__
 from PyQt4.QtCore import pyqtSignal, Qt, QPoint, QRect, QSize
-from PyQt4.QtGui import QUndoCommand, QImage, QWidget, QColor, QPixmap, QSizePolicy, \
+from PyQt4.QtGui import QUndoCommand, QImage, QWidget, QColor, QPixmap, \
-QUndoStack, qRgba, QPainter, QApplication, QCursor, QBrush, QDialog, qGray, qAlpha
+QSizePolicy, QUndoStack, qRgba, QPainter, QApplication, QCursor, \
+QBrush, QDialog, qGray, qAlpha
 from E5Gui import E5MessageBox
 from .cursors import cursors_rc     # __IGNORE_WARNING__
 """
 Constructor
 @param grid reference to the icon editor grid (IconEditorGrid)
 @param text text for the undo command (string)
-@param oldImage copy of the icon before the changes were applied (QImage)
+@param oldImage copy of the icon before the changes were applied
+(QImage)
 @param parent reference to the parent command (QUndoCommand)
 """
 super(IconEditCommand, self).__init__(text, parent)
 self.__grid = grid
 """
 Class implementing the icon editor grid.
 @signal canRedoChanged(bool) emitted after the redo status has changed
 @signal canUndoChanged(bool) emitted after the undo status has changed
-@signal clipboardImageAvailable(bool) emitted to signal the availability of an
+@signal clipboardImageAvailable(bool) emitted to signal the availability
-image to be pasted
+of an image to be pasted
 @signal colorChanged(QColor) emitted after the drawing color was changed
 @signal imageChanged(bool) emitted after the image was modified
-@signal positionChanged(int, int) emitted after the cursor poition was changed
+@signal positionChanged(int, int) emitted after the cursor poition was
+changed
 @signal previewChanged(QPixmap) emitted to signal a new preview pixmap
-@signal selectionAvailable(bool) emitted to signal a change of the selection
+@signal selectionAvailable(bool) emitted to signal a change of the
+selection
 @signal sizeChanged(int, int) emitted after the size has been changed
 @signal zoomChanged(int) emitted to signal a change of the zoom value
 """
 canRedoChanged = pyqtSignal(bool)
 canUndoChanged = pyqtSignal(bool)
 pix.setMask(mask)
 self.__rubberCursor = QCursor(pix, 1, 16)
 def __initUndoTexts(self):
 """
-Private method to initialize texts to be associated with undo commands for
+Private method to initialize texts to be associated with undo commands
-the various drawing tools.
+for the various drawing tools.
 """
 self.__undoTexts = {
 self.Pencil: self.trUtf8("Set Pixel"),
 self.Rubber: self.trUtf8("Erase Pixel"),
 self.Line: self.trUtf8("Draw Line"),
 def setDirty(self, dirty, setCleanState=False):
 """
 Public slot to set the dirty flag.
 @param dirty flag indicating the new modification status (boolean)
-@param setCleanState flag indicating to set the undo stack to clean (boolean)
+@param setCleanState flag indicating to set the undo stack to clean
+(boolean)
 """
 self.__dirty = dirty
 self.imageChanged.emit(dirty)
 if not dirty and setCleanState:
 if self.__curTool in [self.RectangleSelection, self.CircleSelection]:
 self.__selecting = True
 else:
 self.__selecting = False
-if self.__curTool in [self.RectangleSelection, self.CircleSelection, self.Line,
+if self.__curTool in [self.RectangleSelection, self.CircleSelection,
-self.Rectangle, self.FilledRectangle,
+self.Line, self.Rectangle, self.FilledRectangle,
 self.Circle, self.FilledCircle,
 self.Ellipse, self.FilledEllipse]:
 self.setCursor(self.__aimCursor)
 elif self.__curTool == self.Fill:
 self.setCursor(self.__fillCursor)
 if self.__zoom >= 3 and self.__gridEnabled:
 painter.setPen(self.palette().windowText().color())
 i = 0
 while i <= self.__image.width():
-painter.drawLine(self.__zoom * i, 0,
+painter.drawLine(
-self.__zoom * i, self.__zoom * self.__image.height())
+self.__zoom * i, 0,
+self.__zoom * i, self.__zoom * self.__image.height())
 i += 1
 j = 0
 while j <= self.__image.height():
-painter.drawLine(0,  self.__zoom * j,
+painter.drawLine(
-self.__zoom * self.__image.width(), self.__zoom * j)
+0,  self.__zoom * j,
+self.__zoom * self.__image.width(), self.__zoom * j)
 j += 1
 col = QColor("#aaa")
 painter.setPen(Qt.DashLine)
 for i in range(0, self.__image.width()):
 rect = self.__pixelRect(i, j)
 if evt.region().intersects(rect):
 color = QColor.fromRgba(self.__image.pixel(i, j))
 painter.fillRect(rect, QBrush(Qt.white))
 painter.fillRect(QRect(rect.topLeft(), rect.center()), col)
-painter.fillRect(QRect(rect.center(), rect.bottomRight()), col)
+painter.fillRect(QRect(rect.center(), rect.bottomRight()),
+col)
 painter.fillRect(rect, QBrush(color))
 if self.__isMarked(i, j):
 painter.drawRect(rect.adjusted(0, 0, -1, -1))
 """
 Private method to determine the rectangle for a given pixel coordinate.
 @param i x-coordinate of the pixel in the image (integer)
 @param j y-coordinate of the pixel in the image (integer)
-return rectangle for the given pixel coordinates (QRect)
+@return rectangle for the given pixel coordinates (QRect)
 """
 if self.__zoom >= 3 and self.__gridEnabled:
 return QRect(self.__zoom * i + 1, self.__zoom * j + 1,
 self.__zoom - 1, self.__zoom - 1)
 else:
-return QRect(self.__zoom * i, self.__zoom * j, self.__zoom, self.__zoom)
+return QRect(self.__zoom * i, self.__zoom * j,
+self.__zoom, self.__zoom)
 def mousePressEvent(self, evt):
 """
 Protected method to handle mouse button press events.
 self.__currentUndoCmd.setAfterImage(self.__image)
 self.__currentUndoCmd = None
 if self.__curTool not in [self.Pencil, self.Rubber,
 self.Fill, self.ColorPicker,
-self.RectangleSelection, self.CircleSelection]:
+self.RectangleSelection,
+self.CircleSelection]:
 cmd = IconEditCommand(self, self.__undoTexts[self.__curTool],
 self.__image)
 if self.__drawTool(evt.pos(), False):
 self.__undoStack.push(cmd)
 cmd.setAfterImage(self.__image)
 @param pos widget position of the paste rectangle (QPoint)
 """
 self.__markImage.fill(self.NoMarkColor.rgba())
 if self.__pasteRect.isValid():
-self.__updateImageRect(self.__pasteRect.topLeft(),
+self.__updateImageRect(
-self.__pasteRect.bottomRight() + QPoint(1, 1))
+self.__pasteRect.topLeft(),
+self.__pasteRect.bottomRight() + QPoint(1, 1))
 x, y = self.__imageCoordinates(pos)
 isize = self.__image.size()
 if x + self.__clipboardSize.width() <= isize.width():
 sx = self.__clipboardSize.width()
 self.__updateImageRect(self.__pasteRect.topLeft(),
 self.__pasteRect.bottomRight() + QPoint(1, 1))
 def __drawTool(self, pos, mark):
 """
-Public method to perform a draw operation depending of the current tool.
+Public method to perform a draw operation depending of the current
+tool.
 @param pos widget coordinate to perform the draw operation at (QPoint)
 @param mark flag indicating a mark operation (boolean)
-@param flag indicating a successful draw (boolean)
+@return flag indicating a successful draw (boolean)
 """
 self.__unMark()
 if mark:
 self.__endPos = QPoint(pos)
 r = max(abs(start.x() - end.x()), abs(start.y() - end.y()))
 if self.__curTool in [self.FilledCircle, self.CircleSelection]:
 painter.setBrush(QBrush(drawColor))
 painter.drawEllipse(start, r, r)
 if self.__selecting:
-self.__selRect = QRect(start.x() - r, start.y() - r, 2 * r + 1, 2 * r + 1)
+self.__selRect = QRect(start.x() - r, start.y() - r,
+2 * r + 1, 2 * r + 1)
 self.__selectionAvailable = True
 self.selectionAvailable.emit(True)
 elif self.__curTool in [self.Ellipse, self.FilledEllipse]:
 r1 = abs(start.x() - end.x())
 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)
+@param pos1 top, left position for the update in widget coordinates
-@param pos2 bottom, right position for the update in widget coordinates (QPoint)
+(QPoint)
+@param pos2 bottom, right position for the update in widget
+coordinates (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)
+@param ipos1 top, left position for the update in image coordinates
-@param ipos2 bottom, right position for the update in image coordinates (QPoint)
+(QPoint)
+@param ipos2 bottom, right position for the update in image
+coordinates (QPoint)
 """
 r1 = self.__pixelRect(ipos1.x(), ipos1.y())
 r2 = self.__pixelRect(ipos2.x(), ipos2.y())
 left = min(r1.x(), r2.x())
 p = QPixmap.fromImage(self.__image)
 return p
 def __checkClipboard(self):
 """
-Private slot to check, if the clipboard contains a valid image, and signal
+Private slot to check, if the clipboard contains a valid image, and
-the result.
+signal the result.
 """
 ok = self.__clipboardImage()[1]
 self.__clipboardImageAvailable = ok
 self.clipboardImageAvailable.emit(ok)
 @param cut flag indicating to cut the selection (boolean)
 @return image of the selection (QImage)
 """
 if cut:
-cmd = IconEditCommand(self, self.trUtf8("Cut Selection"), self.__image)
+cmd = IconEditCommand(self, self.trUtf8("Cut Selection"),
+self.__image)
 img = QImage(self.__selRect.size(), QImage.Format_ARGB32)
 img.fill(qRgba(0, 0, 0, 0))
 for i in range(0, self.__selRect.width()):
 for j in range(0, self.__selRect.height()):
 if self.__image.rect().contains(self.__selRect.x() + i,
 self.__selRect.y() + j):
-if self.__isMarked(self.__selRect.x() + i, self.__selRect.y() + j):
+if self.__isMarked(
-img.setPixel(i, j, self.__image.pixel(self.__selRect.x() + i,
+self.__selRect.x() + i, self.__selRect.y() + j):
-self.__selRect.y() + j))
+img.setPixel(i, j, self.__image.pixel(
+self.__selRect.x() + i, self.__selRect.y() + j))
 if cut:
 self.__image.setPixel(self.__selRect.x() + i,
 self.__selRect.y() + j,
 qRgba(0, 0, 0, 0))
 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)
+@param pasting flag indicating part two of the paste operation
+(boolean)
 """
 img, ok = self.__clipboardImage()
 if ok:
-if img.width() > self.__image.width() or img.height() > self.__image.height():
+if img.width() > self.__image.width() or \
+img.height() > self.__image.height():
 res = E5MessageBox.yesNo(self,
 self.trUtf8("Paste"),
-self.trUtf8("""<p>The clipboard image is larger than the current """
+self.trUtf8(
-"""image.<br/>Paste as new image?</p>"""))
+"""<p>The clipboard image is larger than the"""
+""" current image.<br/>Paste as new image?</p>"""))
 if res:
 self.editPasteAsNew()
 return
 elif not pasting:
 self.__isPasting = True
 self.__clipboardSize = img.size()
 else:
-cmd = IconEditCommand(self, self.trUtf8("Paste Clipboard"), self.__image)
+cmd = IconEditCommand(self, self.trUtf8("Paste Clipboard"),
+self.__image)
 self.__markImage.fill(self.NoMarkColor.rgba())
 painter = QPainter(self.__image)
 painter.setPen(self.penColor())
 painter.setCompositionMode(self.__compositingMode)
-painter.drawImage(self.__pasteRect.x(), self.__pasteRect.y(), img, 0, 0,
+painter.drawImage(
-self.__pasteRect.width() + 1, self.__pasteRect.height() + 1)
+self.__pasteRect.x(), self.__pasteRect.y(), img, 0, 0,
+self.__pasteRect.width() + 1,
+self.__pasteRect.height() + 1)
 self.__undoStack.push(cmd)
 cmd.setAfterImage(self.__image)
-self.__updateImageRect(self.__pasteRect.topLeft(),
+self.__updateImageRect(
-self.__pasteRect.bottomRight() + QPoint(1, 1))
+self.__pasteRect.topLeft(),
+self.__pasteRect.bottomRight() + QPoint(1, 1))
 else:
 E5MessageBox.warning(self,
 self.trUtf8("Pasting Image"),
 self.trUtf8("""Invalid image data in clipboard."""))
 """
 Public slot to paste the clipboard as a new image.
 """
 img, ok = self.__clipboardImage()
 if ok:
-cmd = IconEditCommand(self, self.trUtf8("Paste Clipboard as New Image"),
+cmd = IconEditCommand(
-self.__image)
+self, self.trUtf8("Paste Clipboard as New Image"),
+self.__image)
 self.setIconImage(img)
 self.setDirty(True)
 self.__undoStack.push(cmd)
 cmd.setAfterImage(self.__image)
 from .IconSizeDialog import IconSizeDialog
 dlg = IconSizeDialog(self.__image.width(), self.__image.height())
 res = dlg.exec_()
 if res == QDialog.Accepted:
 newWidth, newHeight = dlg.getData()
-if newWidth != self.__image.width() or newHeight != self.__image.height():
+if newWidth != self.__image.width() or \
-cmd = IconEditCommand(self, self.trUtf8("Resize Image"), self.__image)
+newHeight != self.__image.height():
-img = self.__image.scaled(newWidth, newHeight, Qt.IgnoreAspectRatio,
+cmd = IconEditCommand(self, self.trUtf8("Resize Image"),
-Qt.SmoothTransformation)
+self.__image)
+img = self.__image.scaled(
+newWidth, newHeight, Qt.IgnoreAspectRatio,
+Qt.SmoothTransformation)
 self.setIconImage(img)
 self.setDirty(True)
 self.__undoStack.push(cmd)
 cmd.setAfterImage(self.__image)
 def grayScale(self):
 """
 Public slot to convert the image to gray preserving transparency.
 """
-cmd = IconEditCommand(self, self.trUtf8("Convert to Grayscale"), self.__image)
+cmd = IconEditCommand(self, self.trUtf8("Convert to Grayscale"),
+self.__image)
 for x in range(self.__image.width()):
 for y in range(self.__image.height()):
 col = self.__image.pixel(x, y)
 if col != qRgba(0, 0, 0, 0):
 gray = qGray(col)
-self.__image.setPixel(x, y, qRgba(gray, gray, gray, qAlpha(col)))
+self.__image.setPixel(
+x, y, qRgba(gray, gray, gray, qAlpha(col)))
 self.update()
 self.setDirty(True)
 self.__undoStack.push(cmd)
 cmd.setAfterImage(self.__image)

Mercurial Repositories > eric / file comparison

comparison: IconEditor/IconEditorGrid.py

IconEditor/IconEditorGrid.py