My program uses a for loop to animate color LED's (fading between colors stored in an array), started by clicking a button on my user interface (using the arduino microcontroller).  I have two problems:  first off, I'd like to be able to stop the loop at any time by clicking the mouse on the button again, but during the loop the program ignores any input.  Is there any way to stop a for loop during execution?  Also, I'd like the user interface to change while running the loop, by calling some draw functions from the loop.  However, the UI won't change until the loop is complete, and if I move another window over the program window it will be blank until the loops stops.  I'm using Processing 0156 Beta on a Windows XP machine.  Here's the code:

void Animate()
{
 //toggles the animate button on and off
 N++;
 float stat = pow(X, N);
 DrawAnimateButton(stat);
 
 //load the color data from the file
 int animateArray[] = int(loadStrings("SaveColor.ddd"));
 float Red = 0;                                              //holds the red value
 float Green = 0;                                            //holds the green value
 float Blue = 0;                                             //holds the blue value
 
 float Rdiff = 0;                                            //the calculated values between the initial and final colors
 float Gdiff = 0;  
 float Bdiff = 0;
 float time = 300;                                           //varies the fade time between each stored color
 
 float arrHolder[] = new float[7];                           //temporary storage for the working colors
 
 //increment through successive colors in the array
 for (int i = 0; i < ArrSize - 5; i = i + 3)
 {
   //stops the loop when no more colors are found in the array
   if (animateArray[i] + animateArray[i + 1] + animateArray[i + 2] == 0)
   {
     LEDcontrol('R', 0);
     LEDcontrol('G', 0);
     LEDcontrol('B', 0);
     break;
   }
   
   //load the working colors into the temporary storage
   for (int ind = 0; ind < 6; ind++)
   {
     arrHolder[ind] = animateArray[i + ind];
   }
   
   //find the difference between each successive color
   Rdiff = (arrHolder[3] - (arrHolder[0]));
   Gdiff = (arrHolder[4] - (arrHolder[1]));
   Bdiff = (arrHolder[5] - (arrHolder[2]));
   
   //initialize the colors to the first stored color
   Red = arrHolder[0];
   Green = arrHolder[1];
   Blue = arrHolder[2];
   
   //fades between the two working colors
   for (int a = 0; a < time; a++)
   {
     
     //none of these work.  They should redraw the interface every time the values
     //are incremented, but the interface remains locked out for the duration of the loop.
     DrawColorSample(int(Red), int(Green), int(Blue));
     Rmouse = int(Red);
     Gmouse = int(Green);
     Bmouse = int(Blue);
     DrawGrid();
     
     //sends the current color to the LED array
     if (Red >= 0)
     {
       LEDcontrol('R', Red);
     }
     
     if (Green >= 0)
     {
       LEDcontrol('G', .45 * Green);
     }
     
     if (Blue >= 0)
     {
       LEDcontrol('B', .545 * Blue);
     }
     
     //increments the colors over time from the initial value to the final value
     Red = Red + Rdiff/time;
     Green = Green + Gdiff/time;
     Blue = Blue + Bdiff/time;
   }
 delay(10000);
 }
 //toggle the animate button off after the loop is completed
 N++;
 stat = pow(X, N);
 DrawAnimateButton(stat);
}

I'm trying to grasp the concepts here, I'm still fairly new to programming so excuse my ignorance.  When you say to use draw() calls, do you mean that I need to somehow put the animation code into the draw() function?  I did actually try that, and the same thing happened.  I'm not entirely sure how to go about using the frameCount variable to iterate my loop, is it possible you could provide a simple code example of how this might be done?  I appreciate the help, thanks!

Thought you might like to know, your concept worked great!  It was a bit of a struggle for me to convert the code to work from draw(), but once I figured it out the animation works perfectly.  Here's the final code:

 if (stat < 0)
 {    
   int animateArray[] = int(loadStrings("SaveColor.ddd"));  //load the color data from the file
   
   for (int in = 0; in < 7; in++)
   {
     arrHolder[in] = 0;
   }
   if (index < 48)
   {
     
     //load the working colors into the temporary storage
     if (refreshCount % time == 0)
     {
     
       arrHolder[0] = animateArray[index];
       arrHolder[1] = animateArray[index + 1];
       arrHolder[2] = animateArray[index + 2];
       arrHolder[3] = animateArray[index + 3];
       arrHolder[4] = animateArray[index + 4];
       arrHolder[5] = animateArray[index + 5];
       
       
       //find the difference between each successive color
       Rdiff = (arrHolder[3] - (arrHolder[0]));
       Gdiff = (arrHolder[4] - (arrHolder[1]));
       Bdiff = (arrHolder[5] - (arrHolder[2]));      
     
       //initialize the colors to the first stored color
       Red = arrHolder[0];
       Green = arrHolder[1];
       Blue = arrHolder[2];
     }
     
     //fades between the two working colors
     if (refreshCount <= time * 16)
     {
       
       DrawColorSample(int(Red), int(Green), int(Blue));
       Rmouse = int(Red);
       Gmouse = int(Green);
       Bmouse = int(Blue);
       DrawGrid();
       
       //sends the current color to the LED array
     
       LEDcontrol('R', .5 * Red);
       delay(10);    
       LEDcontrol('G', .45 * Green);
       delay(10);    
       LEDcontrol('B', .545 * Blue);
       delay(10);    
     
       //increments the colors over time from the initial value to the final value
       Red = abs(Red + Rdiff/time);
       Green = abs(Green + Gdiff/time);
       Blue = abs(Blue + Bdiff/time);
       refreshCount++;
       //println(refreshCount);
     }
     if (refreshCount % time == 0)
     {
     index = index + 3;
     }
     if (index == 48)
     {
       index = 0;
       refreshCount = 0;
     }
     //println(index);
   }
 }