/** Overrides superclass method. Initializes editor component. */
protected void initializeCloneableEditor(CloneableEditor editor) {
DataObject obj = getDataObject();
if (obj.isValid()) {
org.openide.nodes.Node ourNode = obj.getNodeDelegate();
editor.setActivatedNodes(new org.openide.nodes.Node[] {ourNode});
editor.setIcon(ourNode.getIcon(java.beans.BeanInfo.ICON_COLOR_16x16));
NodeListener nl = new DataNodeListener(editor);
ourNode.addNodeListener(WeakListener.node(nl, ourNode));
nodeL = nl;
}
}
/**
* Implements children for basic source code patterns
*
* @author Petr Hrebejk, Jan Jancura
*/
public class PatternChildren extends ClassChildren {
private boolean wri = true;
private MethodElementListener methodListener = new MethodElementListener();
private FieldElementListener fieldListener = new FieldElementListener();
private PropertyChangeListener weakMethodListener =
WeakListener.propertyChange(methodListener, null);
// = new WeakListener.PropertyChange( methodListener );
private PropertyChangeListener weakFieldListener =
WeakListener.propertyChange(fieldListener, null);;
// = new WeakListener.PropertyChange( fieldListener );
static {
Integer i =
new Integer(
PatternFilter.METHOD
| PatternFilter.PROPERTY
| PatternFilter.IDXPROPERTY
| PatternFilter.EVENT_SET);
propToFilter.put(ElementProperties.PROP_METHODS, i);
i =
new Integer(
PatternFilter.FIELD
| PatternFilter.PROPERTY
| PatternFilter.IDXPROPERTY
| PatternFilter.EVENT_SET);
propToFilter.put(ElementProperties.PROP_FIELDS, i);
}
/** Object for finding patterns in class */
private PatternAnalyser patternAnalyser;
// Constructors -----------------------------------------------------------------------
/**
* Create pattern children. The children are initilay unfiltered.
*
* @param elemrent the atteached class. For this class we recognize the patterns
*/
public PatternChildren(ClassElement classElement) {
super(classElement);
patternAnalyser = new PatternAnalyser(classElement);
}
public PatternChildren(ClassElement classElement, boolean isWritable) {
this(classElement);
wri = isWritable;
}
/**
* Create pattern children. The children are initilay unfiltered.
*
* @param elemrent the atteached class. For this class we recognize the patterns
*/
public PatternChildren(ElementNodeFactory factory, ClassElement classElement) {
super(factory, classElement);
patternAnalyser = new PatternAnalyser(classElement);
}
public PatternChildren(
ElementNodeFactory factory, ClassElement classElement, boolean isWritable) {
this(factory, classElement);
wri = isWritable;
}
/*
PatternChildren cloneChildren() {
return.clone();
System.out.println ( "CLONING CHILDREN" );
return new PatternChildren( patternAnalyser.getClassElement() );
}
*/
// FilterCookie implementation --------------------------------------------------------
/** Updates all the keys (elements) according to the current filter & ordering. */
protected void refreshAllKeys() {
cpl = new Collection[getOrder().length];
refreshKeys(PatternFilter.ALL);
}
/** Updates all the keys with given filter. Overriden to provide package access tothis method. */
protected void refreshKeys(int filter) {
// Method is added or removed ve have to re-analyze the pattern abd to
// registrate Children as listener
reassignMethodListener();
reassignFieldListener();
patternAnalyser.analyzeAll();
super.refreshKeys(filter);
// Thread.dumpStack();
}
/**
* @return The class of currently associated filter or null if no filter is associated with these
* children
*/
public Class getFilterClass() {
return PatternFilter.class;
}
/** Gets the pattern analyser which manages the patterns */
PatternAnalyser getPatternAnalyser() {
return patternAnalyser;
}
// Children.keys implementation -------------------------------------------------------
/** Creates node for given key. */
protected Node[] createNodes(Object key) {
if (key instanceof IdxPropertyPattern)
return new Node[] {new IdxPropertyPatternNode((IdxPropertyPattern) key, wri)};
if (key instanceof PropertyPattern)
return new Node[] {new PropertyPatternNode((PropertyPattern) key, wri)};
if (key instanceof EventSetPattern)
return new Node[] {new EventSetPatternNode((EventSetPattern) key, wri)};
// Unknown pattern
return super.createNodes(key);
}
// Utility methods --------------------------------------------------------------------
protected Collection getKeysOfType(int elementType) {
LinkedList keys = (LinkedList) super.getKeysOfType(elementType);
LinkedList temp = null;
if ((elementType & PatternFilter.PROPERTY) != 0) {
temp = new LinkedList();
temp.addAll(patternAnalyser.getPropertyPatterns());
Collections.sort(temp, new PatternComparator());
keys.addAll(temp);
// keys.addAll( patternAnalyser.getPropertyPatterns() );
}
if ((elementType & PatternFilter.IDXPROPERTY) != 0) {
temp = new LinkedList();
temp.addAll(patternAnalyser.getIdxPropertyPatterns());
Collections.sort(temp, new PatternComparator());
keys.addAll(temp);
// keys.addAll( patternAnalyser.getIdxPropertyPatterns() );
}
if ((elementType & PatternFilter.EVENT_SET) != 0) {
temp = new LinkedList();
temp.addAll(patternAnalyser.getEventSetPatterns());
Collections.sort(temp, new PatternComparator());
keys.addAll(temp);
// keys.addAll( patternAnalyser.getEventSetPatterns() );
}
// if ((filter == null) || filter.isSorted ())
// Collections.sort (keys, comparator);
return keys;
}
/** Method for removing method listener */
private void reassignMethodListener() {
MethodElement[] methods = element.getMethods();
for (int i = 0; i < methods.length; i++) {
methods[i].removePropertyChangeListener(weakMethodListener);
methods[i].addPropertyChangeListener(weakMethodListener);
}
}
/** Method for removing field listener */
private void reassignFieldListener() {
FieldElement[] fields = element.getFields();
for (int i = 0; i < fields.length; i++) {
fields[i].removePropertyChangeListener(weakFieldListener);
fields[i].addPropertyChangeListener(weakFieldListener);
}
}
// Inner classes ----------------------------------------------------------------------
/** The listener of method changes temporary used in PatternAnalyser to track changes in */
final class MethodElementListener implements PropertyChangeListener {
public void propertyChange(PropertyChangeEvent e) {
refreshKeys(PatternFilter.ALL);
// patternAnalyser.analyzeAll();
}
}
/** The listener of method changes temporary used in PatternAnalyser to track changes in */
final class FieldElementListener implements PropertyChangeListener {
public void propertyChange(PropertyChangeEvent e) {
refreshKeys(PatternFilter.ALL);
// reassignFieldListener();
// patternAnalyser.resolveFields();
}
}
private static final class PatternComparator implements Comparator {
public int compare(Object a, Object b) {
return ((Pattern) a).getName().compareTo(((Pattern) b).getName());
}
public boolean equals(Object c) {
return c instanceof PatternComparator;
}
}
}