Thread: How to tell a JPanel, that one of the JPanels it contains has been clicked?

There is probably some fancy way of doing it, but the easiest way I can think of is to make the PuzzlePanels have a backwards reference to the Puzzle class (I assume each PuzzlePanel is only in one Puzzle at a time). Then have a variable in the Puzzle class for "selected" and make the selected PuzzelPanel update that variable when it's selected.
Alternatively, you can add a "selected" boolean to the PuzzlePanel, and simply make the Puzzle class recurse through its child PuzzlePanel objects to find a PuzzlePanel with "selected" set to "true"...
Just brain storming. There are probably "better" solutions.

Do me a favor:
Add a MouseListener to Puzzle, and print something out when mouseClicked(), to see if it picks it up.

If it does pick it up, we can listen to the mouse clicks from the Puzzle instead of the individual PuzzlePanels, and then determine which PuzzlePanel was clicked. This way we don't have to implement any timers or anything and we can keep it event-driven (like the Java Gods intended).
If it doesn't pick up the mouse click, we can set up our own event trigger to send back up to Puzzle.

I presume your Puzzle contains references to the PuzzlePanel's (if not directly, it does so via its JPanel tree of children), so you can just add a MouseListener (from the Puzzle class) to each of the child PuzzlePanels. Note in so doing, the fired event will have it's data relative to the PuzzlePanel who fired the event (for instance, getPoint() refers to the event location in the child PuzzlePanel responsible for the event).

Ok, so the MouseListener doesn't work on Puzzle if one is on PuzzlePanel? That sucks... Ok, we will be a bit more inventive and do something a bit more "fun".
There are easier ways to do this, but I'll teach you a nifty little trick. We'll create our own event-handling.
To do this, we need a new interface:

import java.util.EventListener;
import java.util.EventObject;
public interface ClickedPuzzleEventListener extends EventListener {
	/**
	 * @param event the being received
	 */
	public void clickPuzzleEventRecieved(EventObject event);
}

Since we just need the source of the event, we can use a normal old EventObject. If you wanted to include more information in the event's payload, you would create a class which extends from EventObject and add the info for your payload.
Now, ClickedPuzzleEventListener is our new Listener, so we want Puzzle to implement it.
In the Puzzle class, modify it to include:

public class Puzzle extends JPanel implements ClickedPuzzleEventListener {
	private PuzzlePanel selected;
	...
	@Override
	public void clickPuzzleEventRecieved(EventObject event) {
		selected = (PuzzlePanel)event.getSource();
		// Do something now that a PuzzlePanel has been selected
	}
	...
}

And in your PuzzlePanel class, modify it to include:

public class PuzzlePanel extends JPanel ... {
	private Puzzle puzzleParent;
 
	public PuzzlePanel(Puzzle par) {
		super();
		puzzleParent = par;
	}
	...
	/* where ever your mouseClicked method is, perhaps in a MouseListener
	 * implementation or something
	 */
	mouseClicked(MouseEvent e) {
		puzzleParent.clickPuzzleEventRecieved(new EventObject(PuzzlePanel.this));
		// if your MouseListener is its own inner class, you need to say: PuzzelPanel.this
		// if your PuzzlePanel just implements MouseListener, you can just say: this
	}
...
}

And...that should pretty much do the trick. You COULD have skipped the listener and just made the PuzzlePanel set the "selected" variable in Puzzle, but that would not notify Puzzle that a change has been made. With the use of our custom Listener, we can set the "selected" variable AND notify Puzzle when we do, so we can then perform whatever actions in Puzzle which you need to do when the selected PuzzlePanel changes.
Tell me what makes sense and what doesn't.