Update Bleed Generator to process multiple layers

Now works on selected layers instead of just the active one.

bleed_generator_docker/bleed_generator_docker.py

@@ -68,7 +68,7 @@ class BleedGenerator(DockWidget):
         self.setWidget(widget)
 
         # Hook up the action to the button.
-        goButton.clicked.connect( self.generateBleed )
+        goButton.clicked.connect( self.generateBleedLoop )
 
 
     # notifies when views are added or removed
@@ -81,65 +81,79 @@ class BleedGenerator(DockWidget):
     # Slots
     ##########
 
-    # Actually generates the bleed.
-    def generateBleed(self, e):
-
-        # Get the current layer
+    def generateBleedLoop(self, e):
         self.doc = Krita.instance().activeDocument()
-        self.layer = self.doc.activeNode()
-        if self.layer.type() != 'paintlayer':
+
+        # Get the selected layer(s).
+        w = Krita.instance().activeWindow()
+        v = w.activeView()
+        layers = v.selectedNodes()
+        didNotRun = True
+        for layer in layers:
+            if layer.type() == 'paintlayer':
+                self.generateBleed(layer)
+                didNotRun = False
+
+        if didNotRun:
             dialog = QDialog()
             dialog.setWindowTitle("Paint Layer Required")
             layout = QVBoxLayout()
-            layout.addWidget(QLabel('Bleed generator only works on paint layers. Please select one.'))
+            layout.addWidget(QLabel('Bleed Generator only works on paint layers. Please select one.'))
             dialog.setLayout(layout)
             dialog.exec_()
-            return
+        else:
+            # Refresh the view, or changes will not be immediately reflected.
+            self.doc.refreshProjection()
+
+
+    # Actually generates the bleed.
+    def generateBleed(self, layer):
+
         self.offset = round(float(self.offsetInput.text()))
 
         # Calculate how many lines of pixels to copy for each side
-        amounts = self.calculateBleedAmounts()
+        amounts = self.calculateBleedAmounts(layer)
 
         # Copy lines for selected sides.
         # Bounds are fetched each time as layer dimensions change.
         if self.topCheck.checkState():
-            bds = self.layer.bounds()
+            bds = layer.bounds()
             xpos = bds.left()
             ypos = bds.top() - self.offset
             len = bds.width()
-            bleedline = self.layer.pixelData(xpos, ypos, len, 1)
+            bleedline = layer.pixelData(xpos, ypos, len, 1)
             for c in range(1, amounts['top']+1):
-                self.layer.setPixelData(bleedline, xpos, (ypos - c), len, 1)
+                layer.setPixelData(bleedline, xpos, (ypos - c), len, 1)
         if self.botCheck.checkState():
-            bds = self.layer.bounds()
+            bds = layer.bounds()
             xpos = bds.left()
             ypos = bds.bottom() + self.offset
             len = bds.width()
-            bleedline = self.layer.pixelData(xpos, ypos, len, 1)
+            bleedline = layer.pixelData(xpos, ypos, len, 1)
             for c in range(1, amounts['bottom']+1):
-                self.layer.setPixelData(bleedline, xpos, (ypos + c), len, 1)
+                layer.setPixelData(bleedline, xpos, (ypos + c), len, 1)
         if self.leftCheck.checkState():
-            bds = self.layer.bounds()
+            bds = layer.bounds()
             xpos = bds.left() - self.offset
             ypos = bds.top()
             len = bds.height()
-            bleedline = self.layer.pixelData(xpos, ypos, 1, len)
+            bleedline = layer.pixelData(xpos, ypos, 1, len)
             for c in range(1, amounts['left']+1):
-                self.layer.setPixelData(bleedline, (xpos - c), ypos, 1, len)
+                layer.setPixelData(bleedline, (xpos - c), ypos, 1, len)
         if self.rightCheck.checkState():
-            bds = self.layer.bounds()
+            bds = layer.bounds()
             xpos = bds.right() + self.offset
             ypos = bds.top()
             len = bds.height()
-            bleedline = self.layer.pixelData(xpos, ypos, 1, len)
+            bleedline = layer.pixelData(xpos, ypos, 1, len)
             for c in range(1, amounts['right']+1):
-                self.layer.setPixelData(bleedline, (xpos + c), ypos, 1, len)
+                layer.setPixelData(bleedline, (xpos + c), ypos, 1, len)
 
         # Refresh the view, or the cloned pixels will not be immediately shown.
         self.doc.refreshProjection()
 
 
-    def calculateBleedAmounts(self):
+    def calculateBleedAmounts(self, layer):
         amounts = {}
         if self.bleedToBoundsCheck.checkState():
             # Bleed amounts determined from boundaries.
@@ -153,7 +167,7 @@ class BleedGenerator(DockWidget):
             hPoints.insert(0, 0)
             hPoints.append(self.doc.width())
             hPoints.sort()
-            bds = self.layer.bounds()
+            bds = layer.bounds()
 
             # Calculate bleed from layer's edge to next relevant boundary.
             prevV = 0