@gradio/imageeditor 0.14.5 → 0.15.1

package/dist/shared/brush/brush-textures.js

@@ -1,5 +1,62 @@
-import { Container, RenderTexture, Sprite, Graphics, Application } from "pixi.js";
+import { Container, RenderTexture, Sprite, Graphics, Application, Texture } from "pixi.js";
 import {} from "../core/editor";
+import {} from "../core/commands";
+export class BrushCommand {
+    context;
+    layer_id;
+    original_texture;
+    final_texture;
+    name;
+    constructor(context, layer_id, original_texture, final_texture) {
+        this.context = context;
+        this.name = "Draw";
+        this.layer_id = layer_id;
+        this.original_texture = this.createTextureFrom(original_texture);
+        this.final_texture = this.createTextureFrom(final_texture);
+    }
+    /**
+     * Creates a new texture with the same content as the source texture
+     */
+    createTextureFrom(source) {
+        const texture = RenderTexture.create({
+            width: source.width,
+            height: source.height,
+            resolution: window.devicePixelRatio || 1
+        });
+        const sprite = new Sprite(source);
+        const container = new Container();
+        container.addChild(sprite);
+        this.context.app.renderer.render(container, {
+            renderTexture: texture
+        });
+        container.destroy({ children: true });
+        return texture;
+    }
+    async execute() {
+        const layer_textures = this.context.layer_manager.get_layer_textures(this.layer_id);
+        if (!layer_textures)
+            return;
+        const temp_sprite = new Sprite(this.final_texture);
+        const temp_container = new Container();
+        temp_container.addChild(temp_sprite);
+        this.context.app.renderer.render(temp_container, {
+            renderTexture: layer_textures.draw
+        });
+        temp_container.destroy({ children: true });
+    }
+    async undo() {
+        const layer_textures = this.context.layer_manager.get_layer_textures(this.layer_id);
+        if (!layer_textures)
+            return;
+        const temp_sprite = new Sprite(this.original_texture);
+        const temp_container = new Container();
+        temp_container.addChild(temp_sprite);
+        this.context.app.renderer.render(temp_container, {
+            renderTexture: layer_textures.draw
+        });
+        temp_container.destroy({ children: true });
+    }
+}
 /**
  * Class to handle texture operations for the brush tool.
  * Simplified to work directly with layer textures.
@@ -7,7 +64,6 @@ import {} from "../core/editor";
 export class BrushTextures {
     image_editor_context;
     app;
-    // Only keep what we need
     stroke_texture = null;
     erase_texture = null;
     display_container = null;
@@ -16,12 +72,11 @@ export class BrushTextures {
     preview_sprite = null;
     erase_graphics = null;
     dimensions;
-    // Track if a new stroke is starting
     is_new_stroke = true;
-    // Track the current drawing opacity
     current_opacity = 1.0;
-    // Track current drawing mode
     current_mode = "draw";
+    original_layer_texture = null;
+    active_layer_id = null;
     constructor(image_editor_context, app) {
         this.image_editor_context = image_editor_context;
         this.app = app;
@@ -34,29 +89,23 @@ export class BrushTextures {
      * Initializes textures needed for the brush tool.
      */
     initialize_textures() {
-        // Clean up any existing resources
         this.cleanup_textures();
-        // Get dimensions from the image container
         const local_bounds = this.image_editor_context.image_container.getLocalBounds();
         this.dimensions = {
             width: local_bounds.width,
             height: local_bounds.height
         };
-        // Create a texture for the current stroke preview
         this.stroke_texture = RenderTexture.create({
             width: this.dimensions.width,
             height: this.dimensions.height,
             resolution: window.devicePixelRatio || 1
         });
-        // Create a texture for erasing
         this.erase_texture = RenderTexture.create({
             width: this.dimensions.width,
             height: this.dimensions.height,
             resolution: window.devicePixelRatio || 1
         });
-        // Create a container to display preview
         this.display_container = new Container();
-        // Get the active layer and add the display container to it
         const active_layer = this.image_editor_context.layer_manager.get_active_layer();
         if (active_layer) {
             active_layer.addChild(this.display_container);
@@ -64,18 +113,13 @@ export class BrushTextures {
         else {
             this.image_editor_context.image_container.addChild(this.display_container);
         }
-        // Create container for the stroke graphics
         this.stroke_container = new Container();
         this.stroke_graphics = new Graphics();
         this.stroke_container.addChild(this.stroke_graphics);
-        // Create graphics for eraser mask
         this.erase_graphics = new Graphics();
-        // Create a sprite for the preview of the current stroke
         this.preview_sprite = new Sprite(this.stroke_texture);
-        // Start with the preview sprite invisible
         this.preview_sprite.alpha = 0;
         this.display_container.addChild(this.preview_sprite);
-        // Clear the stroke texture
         const clear_container = new Container();
         this.app.renderer.render(clear_container, {
             renderTexture: this.stroke_texture
@@ -84,7 +128,6 @@ export class BrushTextures {
             renderTexture: this.erase_texture
         });
         clear_container.destroy();
-        // Reset drawing state
         this.is_new_stroke = true;
         this.current_opacity = 1.0;
     }
@@ -103,17 +146,14 @@ export class BrushTextures {
      * Cleans up texture resources.
      */
     cleanup_textures() {
-        // Clean up stroke texture
         if (this.stroke_texture) {
             this.stroke_texture.destroy();
             this.stroke_texture = null;
         }
-        // Clean up erase texture
         if (this.erase_texture) {
             this.erase_texture.destroy();
             this.erase_texture = null;
         }
-        // Clean up display container
         if (this.display_container) {
             if (this.display_container.parent) {
                 this.display_container.parent.removeChild(this.display_container);
@@ -121,17 +161,46 @@ export class BrushTextures {
             this.display_container.destroy({ children: true });
             this.display_container = null;
         }
-        // Nullify other references
+        if (this.original_layer_texture) {
+            this.original_layer_texture.destroy();
+            this.original_layer_texture = null;
+        }
         this.stroke_container = null;
         this.stroke_graphics = null;
         this.preview_sprite = null;
         this.erase_graphics = null;
+        this.active_layer_id = null;
     }
     /**
      * Preserve the canvas state when starting a new stroke.
      */
     preserve_canvas_state() {
-        // Reset for a new stroke
+        const active_layer = this.image_editor_context.layer_manager.get_active_layer();
+        if (!active_layer)
+            return;
+        const layers = this.image_editor_context.layer_manager.get_layers();
+        const layer = layers.find((l) => l.container === active_layer);
+        if (!layer)
+            return;
+        this.active_layer_id = layer.id;
+        const layer_textures = this.image_editor_context.layer_manager.get_layer_textures(layer.id);
+        if (!layer_textures)
+            return;
+        if (this.original_layer_texture) {
+            this.original_layer_texture.destroy();
+        }
+        this.original_layer_texture = RenderTexture.create({
+            width: this.dimensions.width,
+            height: this.dimensions.height,
+            resolution: window.devicePixelRatio || 1
+        });
+        const temp_sprite = new Sprite(layer_textures.draw);
+        const temp_container = new Container();
+        temp_container.addChild(temp_sprite);
+        this.app.renderer.render(temp_container, {
+            renderTexture: this.original_layer_texture
+        });
+        temp_container.destroy({ children: true });
         this.is_new_stroke = true;
     }
     /**
@@ -140,79 +209,76 @@ export class BrushTextures {
     reset_eraser_mask() {
         if (!this.erase_graphics || !this.erase_texture)
             return;
-        // Clear and reset the eraser graphics
         this.erase_graphics.clear();
         this.erase_graphics.beginFill(0xffffff, 1);
         this.erase_graphics.drawRect(0, 0, this.dimensions.width, this.dimensions.height);
         this.erase_graphics.endFill();
-        // Render the eraser graphics to the erase texture
         this.app.renderer.render(this.erase_graphics, {
             renderTexture: this.erase_texture
         });
     }
     /**
-     * Commits the current stroke to the active layer.
+     * Commits the current stroke to the active layer and returns a command for undo/redo.
      */
     commit_stroke() {
-        if (!this.stroke_texture || !this.preview_sprite || !this.stroke_graphics)
+        if (!this.stroke_texture ||
+            !this.preview_sprite ||
+            !this.stroke_graphics ||
+            !this.original_layer_texture ||
+            !this.active_layer_id)
             return;
-        // Hide the preview sprite
         this.preview_sprite.visible = false;
-        // Get the active layer's texture
         const active_layer = this.image_editor_context.layer_manager.get_active_layer();
         if (!active_layer)
             return;
-        // Get all layers to find the ID of the active layer
         const layers = this.image_editor_context.layer_manager.get_layers();
         const layer = layers.find((l) => l.container === active_layer);
         if (!layer)
             return;
-        // Get the active layer's draw texture
+        if (layer.id !== this.active_layer_id)
+            return;
         const layer_textures = this.image_editor_context.layer_manager.get_layer_textures(layer.id);
         if (!layer_textures)
             return;
-        // Save the current opacity for use in committing
         const currentOpacity = this.current_opacity;
-        // Handle drawing or erasing
         if (this.current_mode === "draw") {
-            // Drawing mode - simple composition
             const temp_container = new Container();
-            // Add current layer texture as base
             const base_sprite = new Sprite(layer_textures.draw);
             temp_container.addChild(base_sprite);
-            // Add the current stroke with proper opacity
             const stroke_sprite = new Sprite(this.stroke_texture);
             stroke_sprite.alpha = currentOpacity;
             temp_container.addChild(stroke_sprite);
-            // Render the composited result directly to the layer texture
             this.app.renderer.render(temp_container, {
                 renderTexture: layer_textures.draw
             });
-            // Clean up
             temp_container.destroy({ children: true });
         }
         else {
-            // Erasing mode - use proper masking with setMask
             if (!this.stroke_texture)
                 return;
-            // Create a container for the erase operation
             const erase_container = new Container();
-            // Add the current layer content
             const content_sprite = new Sprite(layer_textures.draw);
             erase_container.addChild(content_sprite);
-            // Create the mask sprite from our stroke texture
             const mask_sprite = new Sprite(this.stroke_texture);
-            // Apply the mask to the container using setMask with inverse: true
-            // This will only show content where the mask is NOT (inverse: true)
             erase_container.setMask({ mask: mask_sprite, inverse: true });
-            // Render the masked content back to layer texture
             this.app.renderer.render(erase_container, {
                 renderTexture: layer_textures.draw
             });
-            // Clean up
             erase_container.destroy({ children: true });
         }
-        // Clear the stroke graphics and texture for the next stroke
+        const final_texture = RenderTexture.create({
+            width: this.dimensions.width,
+            height: this.dimensions.height,
+            resolution: window.devicePixelRatio || 1
+        });
+        const final_container = new Container();
+        const final_sprite = new Sprite(layer_textures.draw);
+        final_container.addChild(final_sprite);
+        this.app.renderer.render(final_container, {
+            renderTexture: final_texture
+        });
+        final_container.destroy({ children: true });
+        const brush_command = new BrushCommand(this.image_editor_context, this.active_layer_id, this.original_layer_texture, final_texture);
         if (this.stroke_graphics) {
             this.stroke_graphics.clear();
         }
@@ -221,8 +287,11 @@ export class BrushTextures {
             renderTexture: this.stroke_texture
         });
         clear_container.destroy();
-        // Reset state for the next stroke
         this.is_new_stroke = true;
+        final_texture.destroy();
+        this.original_layer_texture = null;
+        this.active_layer_id = null;
+        this.image_editor_context.command_manager.execute(brush_command);
     }
     /**
      * Calculates the distance between two points.
@@ -239,17 +308,15 @@ export class BrushTextures {
             !this.stroke_container ||
             !this.preview_sprite)
             return;
-        // Store the current mode and opacity
+        if (this.is_new_stroke && !this.original_layer_texture) {
+            this.preserve_canvas_state();
+        }
         this.current_mode = mode;
         this.current_opacity =
             mode === "draw" ? Math.min(Math.max(opacity, 0), 1) : 0.5;
-        // Apply scale to brush size for consistent rendering
         const scaled_size = size;
-        // For new strokes, clear the graphics and texture completely
         if (this.is_new_stroke) {
-            // Clean up for a new stroke
             this.stroke_graphics.clear();
-            // Clear the stroke texture
             const clear_container = new Container();
             this.app.renderer.render(clear_container, {
                 renderTexture: this.stroke_texture
@@ -257,18 +324,14 @@ export class BrushTextures {
             clear_container.destroy();
             this.is_new_stroke = false;
         }
-        // Set fill color and opacity for drawing
         if (mode === "draw") {
-            // For drawing, use the specified color, but always full opacity in the graphics
-            // We need to convert the color string to a number
-            let colorValue = 0xffffff; // Default to white
+            let colorValue = 0xffffff;
             try {
                 if (color.startsWith("#")) {
                     colorValue = parseInt(color.replace("#", "0x"), 16);
                 }
             }
             catch (e) {
-                // Default to white if there's an error
                 colorValue = 0xffffff;
             }
             this.stroke_graphics.setFillStyle({
@@ -277,50 +340,35 @@ export class BrushTextures {
             });
         }
         else {
-            // For erasing, always use white
             this.stroke_graphics.setFillStyle({
                 color: 0xffffff,
                 alpha: 1.0
             });
         }
-        // Calculate the distance between the points
         const distance = this.calculateDistance(from_x, from_y, to_x, to_y);
-        // If the points are the same, just draw a single circle
         if (distance < 0.1) {
-            // Draw a circle at the point - use scaled_size as RADIUS
             this.stroke_graphics.circle(from_x, from_y, scaled_size).fill();
         }
         else {
-            // Calculate how many circles to draw along the path
-            // Adaptive spacing that balances quality and performance
             const spacing = Math.max(scaled_size / 3, 2);
             const steps = Math.max(Math.ceil(distance / spacing), 2);
-            // Draw a circle at each point along the path
             for (let i = 0; i < steps; i++) {
                 const t = i / (steps - 1);
                 const x = from_x + (to_x - from_x) * t;
                 const y = from_y + (to_y - from_y) * t;
-                // Create a circle at this point - use scaled_size as RADIUS
                 this.stroke_graphics.circle(x, y, scaled_size).fill();
             }
         }
-        // End the fill after all circles are drawn
         this.stroke_graphics.endFill();
-        // Render the stroke to the texture
         this.app.renderer.render(this.stroke_container, {
             renderTexture: this.stroke_texture
         });
-        // Update the preview based on mode
         if (mode === "draw") {
-            // For drawing, show the stroke directly with proper opacity
             this.preview_sprite.texture = this.stroke_texture;
             this.preview_sprite.alpha = this.current_opacity;
-            // Set tint to white (no tint) instead of trying to tint the texture
             this.preview_sprite.tint = 0xffffff;
         }
         else {
-            // For erasing, create a preview that shows what will be erased
-            // Get the active layer's texture for preview
             const active_layer = this.image_editor_context.layer_manager.get_active_layer();
             if (!active_layer)
                 return;
@@ -331,13 +379,11 @@ export class BrushTextures {
             const layer_textures = this.image_editor_context.layer_manager.get_layer_textures(layer.id);
             if (!layer_textures)
                 return;
-            // Create a temporary texture for the preview
             const preview_texture = RenderTexture.create({
                 width: this.dimensions.width,
                 height: this.dimensions.height,
                 resolution: window.devicePixelRatio || 1
             });
-            // First, create a copy of the current layer content
             const base_container = new Container();
             const content_sprite = new Sprite(layer_textures.draw);
             base_container.addChild(content_sprite);
@@ -345,26 +391,18 @@ export class BrushTextures {
                 renderTexture: preview_texture
             });
             base_container.destroy({ children: true });
-            // Create a container for the eraser preview with red overlay
             const preview_container = new Container();
-            // Add our current stroke as the content
             const mask_sprite = new Sprite(this.stroke_texture);
-            // Add a red overlay to show what's being erased
             const overlay = new Graphics();
             overlay.setFillStyle({ color: 0xffffff, alpha: 0.5 });
             overlay.rect(0, 0, this.dimensions.width, this.dimensions.height).fill();
-            // Use setMask with inverse: false to only show overlay where the stroke is
-            // We want to show the red overlay ONLY where the stroke will erase
             overlay.setMask({ mask: mask_sprite, inverse: false });
             preview_container.addChild(overlay);
-            // Render the overlay on top of the base content
             this.app.renderer.render(preview_container, {
                 renderTexture: preview_texture
             });
-            // Update the preview sprite with our preview texture
             this.preview_sprite.texture = preview_texture;
             this.preview_sprite.alpha = 1.0;
-            // Clean up
             preview_container.destroy({ children: true });
             preview_texture.destroy();
         }

package/dist/shared/brush/brush.js

@@ -78,36 +78,27 @@ export class BrushTool {
      * @returns {Promise<void>}
      */
     async setup(context, tool, subtool) {
-        // Store context and tool information
         this.image_editor_context = context;
         this.current_tool = tool;
         this.current_subtool = subtool;
-        // Set mode based on tool
         this.state.mode = tool === "erase" ? "erase" : "draw";
-        // Set size based on mode
         if (this.state.mode === "draw") {
             this.state.brush_size = this.brush_size;
         }
         else {
             this.state.brush_size = this.eraser_size;
         }
-        // Subscribe to scale changes
         context.scale.subscribe((scale) => {
             this.scale = scale;
             if (this.brush_cursor) {
                 this.brush_cursor.update_state(this.state, this.scale);
             }
         });
-        // Initialize brush cursor
         this.brush_cursor = new BrushCursor(this.image_editor_context, this.state, this.scale);
-        // Set initial active state
         this.brush_cursor.set_active(tool === "draw" || tool === "erase");
-        // Initialize brush textures
         this.brush_textures = new BrushTextures(this.image_editor_context, context.app);
         this.brush_textures.initialize_textures();
-        // Set up event listeners
         this.setup_event_listeners();
-        // Set cursor style for image container
         this.handle_cursors(tool);
     }
     /**
@@ -116,7 +107,6 @@ export class BrushTool {
      * @private
      */
     handle_cursors(tool) {
-        // Set cursor style to 'none' for all children of the image container
         recurse_set_cursor(this.image_editor_context.image_container.children, "none");
     }
     /**
@@ -125,32 +115,26 @@ export class BrushTool {
      * @param {Subtool} subtool - The current subtool.
      */
     set_tool(tool, subtool) {
-        // Update current tool and subtool
         this.current_tool = tool;
         this.current_subtool = subtool;
         if (this.current_tool !== "erase" && this.current_tool !== "draw") {
             this.commit_pending_changes();
         }
-        // Commit any pending changes
-        // Set brush cursor active state
         if (this.brush_cursor) {
             this.brush_cursor.set_active(tool === "draw" || tool === "erase");
         }
-        // Update mode based on tool
         const new_mode = tool === "erase" ? "erase" : "draw";
         if (tool === "erase" || tool === "draw") {
             this.brush_textures?.initialize_textures();
         }
         if (this.state.mode !== new_mode) {
             this.state.mode = new_mode;
-            // Update brush size based on mode
             if (this.state.mode === "draw") {
                 this.state.brush_size = this.brush_size;
             }
             else {
                 this.state.brush_size = this.eraser_size;
             }
-            // Update cursor
             if (this.brush_cursor) {
                 this.brush_cursor.update_state(this.state, this.scale);
             }
@@ -178,17 +162,13 @@ export class BrushTool {
         }
         if (this.brush_cursor && !this.brush_cursor.is_over_image())
             return;
-        // Preserve the current canvas state
         if (this.brush_textures) {
             this.brush_textures.preserve_canvas_state();
         }
-        // Get the local position
         const local_pos = this.image_editor_context.image_container.toLocal(event.global);
-        // Start drawing
         this.is_drawing = true;
         this.last_x = local_pos.x;
         this.last_y = local_pos.y;
-        // Draw a single point
         if (this.brush_textures) {
             this.brush_textures.draw_segment(local_pos.x, local_pos.y, local_pos.x, local_pos.y, this.state.brush_size, this.state.color, this.state.opacity, this.state.mode);
         }
@@ -199,20 +179,15 @@ export class BrushTool {
      * @private
      */
     on_pointer_move(event) {
-        // Update cursor position
         if (this.brush_cursor) {
             this.brush_cursor.update_cursor_position(event);
         }
-        // If not drawing, exit
         if (!this.is_drawing)
             return;
-        // Get the local position
         const local_pos = this.image_editor_context.image_container.toLocal(event.global);
-        // Draw line from last position to current position
         if (this.brush_textures) {
             this.brush_textures.draw_segment(this.last_x, this.last_y, local_pos.x, local_pos.y, this.state.brush_size, this.state.color, this.state.opacity, this.state.mode);
         }
-        // Update last position
         this.last_x = local_pos.x;
         this.last_y = local_pos.y;
     }
@@ -221,12 +196,9 @@ export class BrushTool {
      * @private
      */
     on_pointer_up() {
-        // If not drawing, exit
         if (!this.is_drawing)
             return;
-        // Stop drawing
         this.is_drawing = false;
-        // Commit the stroke
         if (this.brush_textures) {
             this.brush_textures.commit_stroke();
         }
@@ -237,25 +209,19 @@ export class BrushTool {
      * @private
      */
     setup_event_listeners() {
-        // Remove existing listeners if they exist
         this.cleanup_event_listeners();
-        // Create bound event handlers
         this._bound_pointer_down = this.on_pointer_down.bind(this);
         this._bound_pointer_move = this.on_pointer_move.bind(this);
         this._bound_pointer_up = this.on_pointer_up.bind(this);
-        // Set interactive mode for image container
         const image_container = this.image_editor_context.image_container;
         image_container.eventMode = "static";
         image_container.interactiveChildren = true;
-        // Setup for stage
         const stage = this.image_editor_context.app.stage;
         stage.eventMode = "static";
-        // Add pointer events to the stage for global tracking
         stage.on("pointerdown", this._bound_pointer_down);
         stage.on("pointermove", this._bound_pointer_move);
         stage.on("pointerup", this._bound_pointer_up);
         stage.on("pointerupoutside", this._bound_pointer_up);
-        // Set up cursor event listeners
         if (this.brush_cursor) {
             this.brush_cursor.setup_event_listeners();
         }
@@ -266,7 +232,6 @@ export class BrushTool {
      */
     cleanup_event_listeners() {
         const stage = this.image_editor_context.app.stage;
-        // Remove event listeners if they exist
         if (this._bound_pointer_down) {
             stage.off("pointerdown", this._bound_pointer_down);
             this._bound_pointer_down = null;
@@ -280,7 +245,6 @@ export class BrushTool {
             stage.off("pointerupoutside", this._bound_pointer_up);
             this._bound_pointer_up = null;
         }
-        // Clean up cursor event listeners
         if (this.brush_cursor) {
             this.brush_cursor.cleanup_event_listeners();
         }
@@ -290,12 +254,9 @@ export class BrushTool {
      * @param {number} size - The new brush size.
      */
     set_brush_size(size) {
-        // Set brush size
         this.brush_size = size;
-        // Update state if in draw mode
         if (this.state.mode === "draw") {
             this.state.brush_size = size;
-            // Update cursor
             if (this.brush_cursor) {
                 this.brush_cursor.update_state(this.state, this.scale);
             }
@@ -306,11 +267,8 @@ export class BrushTool {
      * @param {string|ColorInput} color - The new brush color.
      */
     set_brush_color(color) {
-        // Convert to hex string
         const color_string = tinycolor(color).toHexString();
-        // Set color
         this.state.color = color_string;
-        // Update cursor
         if (this.brush_cursor) {
             this.brush_cursor.update_state(this.state, this.scale);
         }
@@ -320,11 +278,8 @@ export class BrushTool {
      * @param {number} opacity - The new brush opacity.
      */
     set_brush_opacity(opacity) {
-        // Clamp opacity between 0 and 1
         const clamped_opacity = Math.max(0, Math.min(1, opacity));
-        // Set opacity
         this.state.opacity = clamped_opacity;
-        // Update cursor
         if (this.brush_cursor) {
             this.brush_cursor.update_state(this.state, this.scale);
         }
@@ -334,12 +289,9 @@ export class BrushTool {
      * @param {number} size - The new eraser size.
      */
     set_eraser_size(size) {
-        // Store the new eraser size
         this.eraser_size = size;
-        // Update state if in erase mode
         if (this.state.mode === "erase") {
             this.state.brush_size = size;
-            // Update cursor
             if (this.brush_cursor) {
                 this.brush_cursor.update_state(this.state, this.scale);
             }
@@ -365,16 +317,12 @@ export class BrushTool {
      * Cleans up resources used by the brush tool.
      */
     cleanup() {
-        // Commit any pending changes
         this.commit_pending_changes();
-        // Clean up event listeners
         this.cleanup_event_listeners();
-        // Clean up brush textures
         if (this.brush_textures) {
             this.brush_textures.cleanup();
             this.brush_textures = null;
         }
-        // Clean up brush cursor
         if (this.brush_cursor) {
             this.brush_cursor.cleanup();
             this.brush_cursor = null;