two different things :

1.
like a spray:
make a couple points around mouseX and mouseY -
those points differ with a random angle and random radius.

This works well:

1. final int maxIterations = 50;  // that's how fast spraying happens
2. //
3. void setup () {
4.   size (700, 700);
5.   stroke(255, 2, 2); // red
6. } // func
7. //
8. void draw () {
9.   if (mousePressed) {
10.     brush () ;
11.   }
12. } // func
13. // -------------------------------------------------------
14. void brush () {
15.   int width1=30; // that be the width of your brush
16.   //
17.   float radx;   // Radius
18.   float rady;
19.   float angle1; // angle
20.   float x;      // result
21.   float y;
22.   //
23.   for (int i=0; i < maxIterations; i++) {
24.     radx=random(width1);
25.     rady=random(width1);
26.     angle1= random(359);
27.     //
28.     x=(radx*cos(radians(angle1)))+mouseX;
29.     y=(radx*sin(radians(angle1)))+mouseY;
30.     //
31.     point(x, y);
32.   }
33. } // func

2.
flood fill
code at http://bazaar.launchpad.net/~philho/+junk/Processing/files/head:/_SmallPrograms/ShowFloodFill/

https://forum.processing.org/topic/flood-fill-turns-unresponsive-on-larger-fill-areas

Thank you so much. The spray tool wasn' t so difficult after all. I am now trying to understand the filltool.

I took a look a phi.lhos Code for flood fill (see link above) and got it working

Greetings, Chrisir

1. // Toxi's flood fill code, updated to modern Java and Processing and to my taste... :-P
2. // Also generalized to work on any PImage
3. // http://processing.org/discourse/yabb2/YaBB.pl?num=1138719727
4. FloodFill1 myFloodFill ;
5. //
6. void setup() {
7.   size(900, 900);
8.   noFill();
9.   strokeWeight(23);
10.   ellipse(190, 190, 90, 90);
11.   rect (390, 390, 90, 90);
12. }
13. //
14. void draw () {
15.   //
16.   // background (117);
17.   //
18.   loadPixels();
19.   myFloodFill = new FloodFill1();
20.   if (mousePressed) {
21.     myFloodFill.DoFill(mouseX, mouseY, color(255, 0, 0));
22.     updatePixels();
23.   }
24. }
25. // =====================================================================
26. // I create a class to share variables between the functions...
27. public class FloodFill1
28. {
29.   protected int iw; // Image width
30.   protected int ih; // Image height
31.   protected color[] imagePixels;
32.   protected color backColor; // Color found at given position
33.   protected color fillColor; // Color to apply
34.   // Stack is almost deprecated and slow (synchronized).
35.   // I would use Deque but that's Java 1.6, excluding current (mid-2009) Macs...
36.   protected ArrayList stack = new ArrayList();
37.   //
38.   public FloodFill1()
39.   {
40.     iw = width;
41.     ih = height;
42.     imagePixels = pixels; // Assume loadPixels have been done before
43.   }
44.   //
45.   public FloodFill1(PImage imageToProcess)
46.   {
47.     iw = imageToProcess.width;
48.     ih = imageToProcess.height;
49.     imagePixels = imageToProcess.pixels; // Assume loadPixels have been done before if sketch image
50.   }
51.   //
52.   public void DoFill(int startX, int startY, color fc)
53.   {
54.     // start filling
55.     fillColor = fc;
56.     backColor = imagePixels[startX + startY * iw];
57.     // don't run if fill color is the same as background one
58.     if (fillColor == backColor)
59.       return;
60.     stack.add(new PVector(startX, startY));
61.     while (stack.size () > 0)
62.     {
63.       PVector p = (PVector) stack.remove(stack.size() - 1);
64.       // Go left
65.       FillScanLine((int) p.x, (int) p.y, -1);
66.       // Go right
67.       FillScanLine((int) p.x + 1, (int) p.y, 1);
68.     }
69.   }
70.   //
71.   protected void FillScanLine(int x, int y, int dir)
72.   {
73.     // compute current index in pixel buffer array
74.     int idx = x + y * iw;
75.     boolean inColorRunAbove = false;
76.     boolean inColorRunBelow = false;
77.     // fill until boundary in current scanline...
78.     // checking neighbouring pixel rows
79.     while (x >= 0 && x < iw && imagePixels[idx] == backColor)
80.     {
81.       imagePixels[idx] = fillColor;
82.       if (y > 0) // Not on top line
83.       {
84.         if (imagePixels[idx - iw] == backColor)
85.         {
86.           if (!inColorRunAbove)
87.           {
88.             // The above pixel needs to be flooded too, we memorize the fact.
89.             // Only once per run of pixels of back color (hence the inColorRunAbove test)
90.             stack.add(new PVector(x, y-1));
91.             inColorRunAbove = true;
92.           }
93.         }
94.         else // End of color run (or none)
95.         {
96.           inColorRunAbove = false;
97.         }
98.       }
99.       if (y < ih - 1) // Not on bottom line
100.       {
101.         if (imagePixels[idx + iw] == backColor)
102.         {
103.           if (!inColorRunBelow)
104.           {
105.             // Idem with pixel below, remember to process there
106.             stack.add(new PVector(x, y + 1));
107.             inColorRunBelow = true;
108.           }
109.         }
110.         else // End of color run (or none)
111.         {
112.           inColorRunBelow = false;
113.         }
114.       }
115.       // Continue in given direction
116.       x += dir;
117.       idx += dir;
118.     } //
119.   } // func
120. } // class
121. // ----------------------------------------------------------

Thank you so much for your time. It seems to be working.That was a great help!