the problem is, that always only the last one works because, setting the cursor is global, so if the first one turns the hand cursor on, the second one turns it off again before it gets drawn to the screen. what you have to do is something like that in the end of draw

  if( button2.over == false && button1.over == false)cursor(ARROW);
 

Thanks, I did not realize this was global.

I am wanting my instances to be in an array that eventually we be able to grow or shrink in size. I seem to run into the same problem when I structure the code for any arbitrary number of buttons. Here's a variation of the above with your suggestion. The problem still exist due to the for loops I think.

Does anyone have any suggestions on how to get this working for an array of button objects?

1. Button[] buttons;
   int num;
   
   void setup() {
     size(200, 200);
     num = 2;                                                  // number of handles
     buttons = new Button[num];
     for(int i=0; i<num; i++) {
       // Inputs: x, y, size, base color, over color, press color
       buttons[i] =  new Button(25, 25+i*50, 20, color(204), color(255), color(0));
     }
   
   
   }
   
   void draw() {
     background(204);
     stroke(255);
     for (int i=0; i<2;i++){
       buttons[i].update();
       buttons[i].display();
       if( buttons[i].over == false)
       {
         cursor(ARROW);
       }
     }
   }
   
   void mousePressed() {
     for (int i=0; i<2;i++){
       buttons[i].press();
     }
   }
   
   void mouseReleased() {
     for (int i=0; i<2;i++){
       buttons[i].release();
     }
   }
   class Button {
     int x, y; // The x- and y-coordinates
     int size; // Dimension (width and height)
     color baseGray; // Default gray value
     color overGray; // Value when mouse is over the button
     color pressGray; // Value when mouse is over and pressed
     boolean over = false; // True when the mouse is over
     boolean pressed = false; // True when the mouse is over and pressed
   
     Button(int xp, int yp, int s, color b, color o, color p) {
       x = xp;
       y = yp;
       size = s;
       baseGray = b;
       overGray = o;
       pressGray = p;
     }
   
     // Updates the over field every frame
     void update() {
       if ((mouseX >= x) && (mouseX <= x + size) &&
         (mouseY >= y) && (mouseY <= y + size)) {
         over = true;
       }
       else {
         over = false;
       }
     }
   
     boolean press() {
       if (over == true) {
         pressed = true;
         return true;
       }
       else {
         return false;
       }
     }
   
     void release() {
       pressed = false; // Set to false when the mouse is released
     }
   
     void display() {
       if (pressed == true) {
         fill(pressGray);
       }
       else if (over == true) {
         fill(overGray);
         cursor(HAND);
       }
       else {
         fill(baseGray);
         //cursor(ARROW);
       }
       stroke(255);
       rect(x, y, size, size);
     }
   }
   
   

You have to manage the all the buttons states at once to see if the cursor isn't over a button:

1. void draw() {
2.   background(204);
3.   stroke(255);
4.   boolean bOver = false;
5.   for (int i=0; i<2;i++){
6.     buttons[i].update();
7.     buttons[i].display();
8.     bOver |= buttons[i].over;
9.   }
10.   if (!bOver) {
11.     cursor(ARROW);
12.   }
13. }

Note: you can simplify a bit your tests, testing a boolean against a value is quite redundant (but some people find redundancy more readable, so it is sometime a question of taste):

1. class Button {
2.   int x, y; // The x- and y-coordinates
3.   int size; // Dimension (width and height)
4.   color baseGray; // Default gray value
5.   color overGray; // Value when mouse is over the button
6.   color pressGray; // Value when mouse is over and pressed
7.   boolean over; // True when the mouse is over
8.   boolean pressed; // True when the mouse is over and pressed
9. 
   
10.   Button(int xp, int yp, int s, color b, color o, color p) {
11.     x = xp;
12.     y = yp;
13.     size = s;
14.     baseGray = b;
15.     overGray = o;
16.     pressGray = p;
17.   }
18. 
    
19.   // Updates the over field every frame
20.   void update() {
21.     over = mouseX >= x && mouseX <= x + size &&
22.         mouseY >= y && mouseY <= y + size;
23.   }
24.   boolean press() {
25.     if (over) {
26.       pressed = true;
27.       return true;
28.     }
29.     return false;
30.   }
31.   void release() {
32.     pressed = false; // Set to false when the mouse is released
33.   }
34.   void display() {
35.     if (pressed) {
36.       fill(pressGray);
37.     }
38.     else if (over) {
39.       fill(overGray);
40.       cursor(HAND);
41.     }
42.     else {
43.       fill(baseGray);
44.       //cursor(ARROW);
45.     }
46.     stroke(255);
47.     rect(x, y, size, size);
48.   }
49. }

Thanks Phil,
That did the trick. Not really up to speed on the bitwise stuff. I will have to study up on it some more before I truly understand it.

All these examples I posted were to help me get this working with a bezier class I have been trying to create based on an example sketch I found in a processing book. I tried to apply the above to it but it just got way too confusing for my pea brain to figure out. I think the problem this time is that there are essentially 4 rollover areas per instance of this class. I can't work out how I would get the hand to show up on all handles. Here is what I have so far.

1. BezierSection[] bezSections;
   int numberOfBeziers;
   
   void setup(){
     smooth();
     size(500,400);
     numberOfBeziers = 2;
     bezSections = new BezierSection[numberOfBeziers];
     for(int i=0; i<numberOfBeziers; i++) {
       // Inputs: t, A.x, A.y, B.x, B.y, C.x, C.y, D.x, D.y
       bezSections[i] = new BezierSection(1, new PVector(50+i*25,height/2), new PVector(50+i*25,height/2-150), new PVector(width-50+i*25,height/2-150), new PVector(width-50+i*25,height/2));
     }
   }
   
   void draw(){
     background(41);
     for(int i=0; i<numberOfBeziers; i++) {
       bezSections[i].display();
     }
   }
   
   void mouseReleased(){
     for(int i=0; i<numberOfBeziers; i++) {
       bezSections[i].release();
     }
   }
   
   void mousePressed(){
     for(int i=0; i<numberOfBeziers; i++) {
       bezSections[i].press();
     }
   }
   
   void mouseMoved(){
     for(int i=0; i<numberOfBeziers; i++) {
       bezSections[i].move();
     }
   }
   class BezierSection{
   
     // variables for control and anchor points.
     int pts = 4;
     int ptSize = 8;
     float[]x = new float[4];
     float[]y = new float[4];
     boolean[]isDragSafe = new boolean[4];
     float[]xOld = new float[4];
     float[]yOld = new float[4];
     float[]xOffset = new float[4];
     float[]yOffset = new float[4];
     boolean[]over = new boolean[4];
   
   
   
   
     BezierSection(float t, PVector A, PVector B, PVector C, PVector D){
   
       // fill coordinate arrays
       xOld[0] = x[0] = A.x;
       xOld[1] = x[1] = B.x;
       xOld[2] = x[2] = C.x;
       xOld[3] = x[3] = D.x;
       yOld[0] = y[0] = A.y;
       yOld[1] = y[1] = B.y;
       yOld[2] = y[2] = C.y;
       yOld[3] = y[3] = D.y;
   
       //initialize dragging flags to false
       for (int i =0; i< pts; i++){
         isDragSafe[i] = false;
       }
   
     }
   
   
     void display(){
       //draw curves and control handles
       strokeWeight(2);
       stroke(138, 216, 20);
       noFill();
       bezier (x[0], y[0],x[1], y[1], x[2], y[2], x[3], y[3]);
       // draw bezier handles
       strokeWeight(2);
       stroke(107);
       line(x[1], y[1], x[0], y[0]);
       line(x[3], y[3], x[2], y[2]);
       // draw anchor/control points
       noStroke();
       fill(0);
       for (int i =0; i< pts; i++){
         if (i ==0 || i==3){
   
           fill(0);
           ellipse(x[i], y[i], ptSize*1.5, ptSize*1.5);
         } 
         else {
           fill(231, 163, 27);
           rectMode(CENTER);
           rect(x[i], y[i], ptSize, ptSize);
         }
       }
   
       // start dragging if flag true
       if (isDragSafe[0]&&isDragSafe[1]){// if it's anchor 1 and it's handle then move them both and add and offset to the handle
         //  getOffset();
         x[0] = mouseX;
         y[0] = mouseY ;
         x[1] = mouseX - xOffset[1];
         y[1] = mouseY - yOffset[1];
         xOld[1] = x[1];
         yOld[1] = y[1];
       }
       if (isDragSafe[1]&&!isDragSafe[0]){
         x[1] = mouseX;
         xOld[1] = x[1];
         y[1] = mouseY;
         yOld[1] = y[1];
       }
       if (isDragSafe[2]&&isDragSafe[3]){// if it's anchor 2 and it's handle then move them both and add and offset to the handle
         x[3] = mouseX;
         y[3] = mouseY;
         x[2] = mouseX - xOffset[2];
         y[2] = mouseY - yOffset[2];
         xOld[2] = x[2];
         yOld[2] = y[2];
       }
       if (isDragSafe[2]&&!isDragSafe[3]){
         x[2] = mouseX;
         xOld[2] = x[2];
         y[2] = mouseY;
         yOld[2] = y[2];
       }
     }
   
   
     void press(){
       for (int i =0; i< pts; i++){
         if (mouseX>=x[i]-5 && mouseX<=x[i]+ptSize+5 && 
           mouseY>=y[i]-5 && mouseY<=y[i]+ptSize+5){
           if(i==0){
             isDragSafe[i] = true;
             isDragSafe[i+1] = true;
             yOffset[1] = (y[0] - yOld[1]);  //Work out the offset between the anchor and the handle
             xOffset[1] = (x[0] - xOld[1]);
           }
           if(i==3){
             isDragSafe[i] = true;
             isDragSafe[i-1] = true;
             yOffset[2] = (y[3] - yOld[2]);  //Work out the offset between the anchor and the handle
             xOffset[2] = (x[3] - xOld[2]);
           }
           else{
             isDragSafe[i] = true;
           }
         }
       }
     }
   
     void release(){
       for (int i =0; i< pts; i++){
         isDragSafe[i] = false;
       }
     }
   
     void move(){
       cursor(ARROW);   
       for (int i =0; i< pts; i++){
         if (mouseX>=x[i]-10 && mouseX<=x[i]+10 && mouseY>=y[i]-10 && mouseY<=y[i]+10){
           cursor(HAND);
         }
       }
     }
   }