Store custom object in JLabel on event

Question

I'm doing a drag and drop of custom objects into JLabels and am able to reference the object during the transfer process (change label String to received object toString), but unsure of how to actually store the custom object in the JLabel or build a reference.

What is the best way to accomplish this during the transfer process?

Here is the working transfer code that receives the object and uses it to set text (much thanks to a previous answer: here:

public boolean importData(TransferSupport support) {
            boolean accept = false;
            if (canImport(support)) {
                try {
                    Transferable t = support.getTransferable();
                    Object value = t.getTransferData(PersonTransferable.PERSON_FLAVOR);
                    if (value instanceof Person) {
                        Component component = support.getComponent();
                        if (component instanceof JLabel) {
                            ((JLabel)component).setText(((Person)value).toString());
                            //action here

                        }
                    }
                } catch (Exception exp) {
                    exp.printStackTrace();
                }
            }
            return accept;
        }

The JLabels have specific instance variables that I'd like to store them to. Since I have the component (JLabel) and value (custom object), can I make this link?

Worst case scenario, I just have to build a TransferHandler for each label and reference the value exactly. Is this maybe best practice anyways?

Answer 1

You have a number of choices that I can see

Choice #1

Create a Map of some kind and store the object against the label, using the label as it's key

Map<JLabel, Person> mapPeople = new HashMap<JLable, Person>(25)

Then in your import method

mapPeople.put((JLabel)component, (Person)value);

Choice #2

Take advantage of the put/getClientProperty to store the value against a named key...

In your import method...

((JLabel)component).putClientProperty("person", value);

And when you need it again

Person person = (Person)label.getClientProperty("person");

Choice #3

Create a custom label that is capable of referencing the person directly.

public class PersonLabel extends JLabel {
    private Person person;
    public void setPerson(Person person) {
        this.person = person;
        setText(person == null ? null : person.toString());
    }

    public Person getPerson() {
        return person;
    }
}

Basically, you would use this component in place of the normal JLabel, make sure you cast it correctly.

Credit to Hovercraft and trashgod for mentioning most of this first.

Final Choice

The final choice will come down to your own design, requirements and how re-usable you want the solution to be.

If this is a "one" off requirement for your application, then the Map and client properties are reasonable solutions.

The Map is more highly visible to other developers, it obvious what you are trying to do. It is, however, easy to mess up. Having the map either contain irrelevant data or have missing data because some one forgot to/or didn't know to follow the requirements.

The clientProperty does solve some the short comings of the Map in this sense, as you a re dealing with a single component, not a component and a Map (although it's still possible for developers to forget to set the property) but has a much lower visibility when compared to the Map. It might take longer for developers to realise how you are storing/retrieving the data.

It does, how ever, have the advantage of been simple. You can pass a reference to the label and you have not just the label, but also the Person as well.

The custom label provides you the opportunity for flexibility. It's more obvious then the clientProperty solution, as it has defined public methods. It also allows you the opportunity to setup the TransferHandler when the label is created, rather then having to establish each one individually each time you want to re-use the solution.

What it's going to come down to is this. Do you want a quick, once of solution, or do you want something to is self-contained and re-usable. The Map and clientProperty choices are relatively quick to implement and use. The custom component will take a little more effort but will generally result in a more re-usable solution. It's all up to you ;)