You could also use two different event handlers, one for each canvas.

So you''d have two inner classes (so they can access the can1 and can2 fields, assuming they''re class members):

public class CanvasOneEventHandler implements MouseListener
{
public void mouseEntered(MouseEvent evt)
{
// do stuff with the can1
}
}

public class CanvasTwoEventHandler implements MouseListener
{
public void mouseEntered(MouseEvent evt)
{
// do stuff with can2
}
}

Another possibility is to do anonymous inner classes:

can1.addMouseListener(new MouseAdapter() {
public void mouseEntered(MouseEvent evt)
{
// do stuff with can1:
// if it''s a local variable in this method, declare it
// as final so you can reference it here
}
});

and the same thing for can2.

But really, if you''re doing can1.addMouseListener() or something similar, then evt.getSource() WILL return can1 if the event occurred on can1, so the test

if (evt.getSource() == can1)

should work.

Now, if UserDefCanvas and OtherUserDefCanvas don''t extend Canvas, then what you can do is add a method to these classes to return the canvas that''s embedded in them (which I assume you''d have to have), so your test changes to something like:

if (evt.getSource() == can1.getCanvas())

This also means that unless you overrode addMouseListener in UserDefCanvas & OtherUserDefCanvas, you wouldn''t be able to add the MouseListener directly to a class instance, anyway.

So basically, if you''re able to add a MouseListener to the class instance itself, evt.getSource() will return the instance of the class on which the event occurred. You can cast it to the appropriate type if you want, too

if (evt.getSource() instanceof UserDefCanvas)
{
UserDefCanvas can = (UserDefCanvas) evt.getSource();
// do stuff with the canvas
}
else if (evt.getSource() instanceof OtherUserDefCanvas)
{
OtherUserDefCanvas can = (OtherUserDefCanvas) evt.getSource();
}

Anyway, hopefullly somewhere in here you''ll find a solution.

.equals may work, but that''s more for checking the CONTENTS of the object. In this case, you want to check against actual object instances, so == is the better choice.
Also, it''s possible[1] that .equals can be overridden, so that you can run into a case where

object.equals(another_object)

returns true, but

object == another_object

returns false. It all depends on what the developer of the object wanted .equals to signify.

In this case, the desire is to compare against a particular object instance, so to guarantee that that''s what''s being checked, I would still recommend using == instead of .equals.

[1] I don''t think that''s the case for Canvas, but I think it''s important to make the distinction of comparing object instances versus object values, when it''s the former that is important to this example.