private void addTagToMethod(
Map<String, MethodInfo> methods, String tagText, MethodTagType tagType) {
MethodInfo mi = methods.get(methodName);
if (mi == null) {
mi = new MethodInfo();
methods.put(methodName, mi);
}
if (tagType == MethodTagType.OMIT_FROM_UI) {
mi.omitFromUI = true;
return;
}
String[] tagParts =
Iterables.toArray(
Splitter.on(WHITESPACE_PATTERN)
.trimResults()
.omitEmptyStrings()
.limit(2)
.split(tagText),
String.class);
if (tagParts.length == 2) {
if (tagType == MethodTagType.DESCRIPTION) {
mi.descriptions.put(tagParts[0], tagParts[1]);
} else {
mi.useSchemas.put(tagParts[0], tagParts[1]);
}
}
}
/**
* Function called when an audio device is plugged or unplugged.
*
* @param event The property change event which may concern the audio device.
*/
public void propertyChange(PropertyChangeEvent event) {
if (DeviceConfiguration.PROP_AUDIO_SYSTEM_DEVICES.equals(event.getPropertyName())) {
NotificationService notificationService = getNotificationService();
if (notificationService != null) {
// Registers only once to the popup message notification
// handler.
if (!isRegisteredToPopupMessageListener) {
isRegisteredToPopupMessageListener = true;
managePopupMessageListenerRegistration(true);
}
// Fires the popup notification.
ResourceManagementService resources = NeomediaActivator.getResources();
Map<String, Object> extras = new HashMap<String, Object>();
extras.put(NotificationData.POPUP_MESSAGE_HANDLER_TAG_EXTRA, this);
notificationService.fireNotification(
DEVICE_CONFIGURATION_HAS_CHANGED,
resources.getI18NString("impl.media.configform" + ".AUDIO_DEVICE_CONFIG_CHANGED"),
resources.getI18NString(
"impl.media.configform" + ".AUDIO_DEVICE_CONFIG_MANAGMENT_CLICK"),
null,
extras);
}
}
}
/**
* @param source
* @param oldScalarMap The previous ScalarMap of the ScalarMapAdapter. May be <code>null</code>.
* @return The controlling ScalarMapAdapter of the display.
* @throws RemoteException
* @throws VisADException
*/
protected final synchronized ScalarMapAdapter accept(
ScalarMapAdapter source, ScalarMap oldScalarMap) throws VisADException, RemoteException {
ScalarMapAdapter adapter;
if (oldScalarMap != null) {
adapter = (ScalarMapAdapter) map.get(oldScalarMap);
if ((adapter != null) && (adapter == source)) {
map.remove(oldScalarMap);
changed = true;
}
}
ScalarMap newScalarMap = source.getScalarMap();
adapter = (ScalarMapAdapter) map.get(newScalarMap);
if (adapter != null) {
source.duplicate(adapter);
} else {
adapter = source;
map.put(newScalarMap, source);
changed = true;
}
if (changed) {
updater.update();
}
return adapter;
}
/*
* Update the TableColumn with the newly calculated width
*/
private void updateTableColumn(int column, int width) {
final TableColumn tableColumn = table.getColumnModel().getColumn(column);
if (!tableColumn.getResizable()) return;
width += spacing;
// Don't shrink the column width
if (isOnlyAdjustLarger) {
width = Math.max(width, tableColumn.getPreferredWidth());
}
columnSizes.put(tableColumn, new Integer(tableColumn.getWidth()));
table.getTableHeader().setResizingColumn(tableColumn);
tableColumn.setWidth(width);
}
@Override
public Image getIcon(final int iconType) {
Image icon = img.get(iconType);
if (icon != null) return icon;
// try to get a special icon
icon = BeanSupport.getBeanIcon(component.getBeanClass(), iconType);
if (icon == null) {
final String className = component.getBeanClass().getName();
final String classDetails =
(String) component.getAuxValue(RADComponent.AUX_VALUE_CLASS_DETAILS);
if (!iconsInitialized) {
// getIconForClass invokes getNodes(true) which cannot be called in Mutex
EventQueue.invokeLater(
new Runnable() {
@Override
public void run() {
Image icon = PaletteUtils.getIconForClass(className, classDetails, iconType, true);
iconsInitialized = true;
if (icon != null) {
img.put(iconType, icon);
fireIconChange();
}
}
});
} else {
icon = PaletteUtils.getIconForClass(className, classDetails, iconType, false);
}
if (icon == null) {
// get icon from BeanInfo
java.beans.BeanInfo bi = component.getBeanInfo();
if (bi != null) {
icon = bi.getIcon(iconType);
}
if (icon == null) {
// use default icon
icon = super.getIcon(iconType);
}
}
}
img.put(iconType, icon);
return icon;
}
/**
* Returns, the <tt>TransportManager</tt> instance for the channel-bundle with ID
* <tt>channelBundleId</tt>. If no instance exists and <tt>create</tt> is <tt>true</tt>, one will
* be created.
*
* @param channelBundleId the ID of the channel-bundle for which to return the
* <tt>TransportManager</tt>.
* @param create whether to create a new instance, if one doesn't exist.
* @return the <tt>TransportManager</tt> instance for the channel-bundle with ID
* <tt>channelBundleId</tt>.
*/
IceUdpTransportManager getTransportManager(String channelBundleId, boolean create) {
IceUdpTransportManager transportManager;
synchronized (transportManagers) {
transportManager = transportManagers.get(channelBundleId);
if (transportManager == null && create && !isExpired()) {
try {
// FIXME: the initiator is hard-coded
// We assume rtcp-mux when bundle is used, so we make only
// one component.
transportManager = new IceUdpTransportManager(this, true, 1);
} catch (IOException ioe) {
throw new UndeclaredThrowableException(ioe);
}
transportManagers.put(channelBundleId, transportManager);
}
}
return transportManager;
}
private Object deserialize(Node node, boolean setProperty, boolean popBean) throws Exception {
Object object = null;
currentType = null;
currentNode = node;
currentName = node.getNodeName();
boolean isNull = false;
NamedNodeMap attrs = node.getAttributes();
String arrayType = null;
for (int i = 0; i < attrs.getLength(); i++) {
String nodeName = attrs.item(i).getNodeName();
String nodeValue = attrs.item(i).getNodeValue();
if (nodeName.equals(NamespaceConstants.NSPREFIX_SCHEMA_XSI + ":" + Constants.ATTR_TYPE))
currentType = new StringBuffer(nodeValue).delete(0, nodeValue.indexOf(':') + 1).toString();
else if (nodeName.equals(
NamespaceConstants.NSPREFIX_SOAP_ENCODING + ":" + Constants.ATTR_ARRAY_TYPE))
arrayType = new StringBuffer(nodeValue).delete(0, nodeValue.indexOf(':') + 1).toString();
else if (nodeName.equals(NamespaceConstants.NSPREFIX_SCHEMA_XSI + ":null"))
isNull = nodeValue.equals("true");
}
Class cls = null;
if (currentType != null) cls = getXsdTypeClass(currentType);
// Handle array, Vector, ArrayList, LinkedList, Hashtable,
// Properties, and HashMap data types
if ((cls != null)
&& ((cls == java.lang.reflect.Array.class)
|| (cls == Vector.class)
|| (cls == ArrayList.class)
|| (cls == LinkedList.class)
|| (cls == Hashtable.class)
|| (cls == Properties.class)
|| (cls == HashMap.class)
|| (cls == SortedMap.class))) {
parentNode = currentNode;
String name = node.getNodeName();
// Handle arrays
if (cls == java.lang.reflect.Array.class) {
int a = arrayType.indexOf("[");
int b = arrayType.indexOf("]");
String s = arrayType.substring(a + 1, b);
int arrayLen = Integer.valueOf(s).intValue();
arrayType = arrayType.substring(0, a);
// check if the array element is a standard Java class
Class arrayClass = getXsdTypeClass(arrayType);
// otherwise try to get the class of the bean
if (arrayClass == null)
arrayClass = getClassOfBean((ClassLoader) classLoaderStrategy, arrayType);
object = java.lang.reflect.Array.newInstance(arrayClass, arrayLen);
} else {
// Construct the list or map type
Constructor ct = cls.getConstructor((Class[]) null);
object = ct.newInstance((Object[]) null);
}
// deserialize the elements of the array, list, or map
NodeList childNodes = node.getChildNodes();
int arrayIndex = -1;
Node childNode = null;
Object nodeObj = null;
for (int i = 0; i < childNodes.getLength(); i++) {
childNode = childNodes.item(i);
if (childNode.getNodeType() == Node.ELEMENT_NODE) {
if ((cls == java.lang.reflect.Array.class)
|| (cls == Vector.class)
|| (cls == ArrayList.class)
|| (cls == LinkedList.class)) {
nodeObj = deserialize(childNode, false, true);
if (nodeObj != null) {
if (cls == java.lang.reflect.Array.class)
java.lang.reflect.Array.set(object, ++arrayIndex, nodeObj);
else ((List) object).add(nodeObj);
}
} else if ((cls == Hashtable.class)
|| (cls == Properties.class)
|| (cls == HashMap.class)
|| (cls == SortedMap.class)) {
if (childNode.getLocalName().equals("item")) {
NodeList htNodes = childNode.getChildNodes();
if (htNodes.getLength() == 2) {
Object hashKey = deserialize(htNodes.item(0), false, false);
Object hashValue = deserialize(htNodes.item(1), false, true);
((Map) object).put(hashKey, hashValue);
}
}
}
}
}
setBeanProperty(name, object);
// Handle everything else (primitives & POJOs)
} else {
// recurse on each of the child nodes
NodeList childNodes = node.getChildNodes();
if ((childNodes != null) && (childNodes.getLength() > 0)) {
for (int i = 0; i < childNodes.getLength(); i++) {
Node childNode = childNodes.item(i);
if (childNode.getNodeType() == Node.ELEMENT_NODE) {
if (currentType != null)
createObject(
node,
currentName,
currentPackage,
currentType,
childNode.getNodeValue(),
setProperty);
parentNode = node;
object = deserialize(childNode, true, true);
} else if ((childNode.getNodeType() == Node.TEXT_NODE) && (currentType != null)) {
object =
createObject(
node,
currentName,
currentPackage,
currentType,
childNode.getNodeValue(),
setProperty);
}
currentType = null;
}
} else {
if (!isNull)
object = createObject(node, currentName, currentPackage, currentType, null, setProperty);
}
if (node.getParentNode() != parentNode) {
parentNode = node.getParentNode();
if (popBean) {
Object bean = popBeanOffStack();
if (bean != null) object = bean;
}
}
}
return object;
}
/** {@inheritDoc} */
@Override
public void setProperty(String propertyName, Object value) {
if (value == null) properties.remove(propertyName);
else properties.put(propertyName, value);
}
public void buildTypeGraph() {
Map<String, JarFile> openJarFiles = new HashMap<String, JarFile>();
Map<String, File> openClassFiles = new HashMap<String, File>();
// use global cache to load resource in/out of the same jar as the classes
Set<String> resourceCacheSet = new HashSet<>();
try {
for (String path : pathsToScan) {
File f = null;
try {
f = new File(path);
if (!f.exists()
|| f.isDirectory()
|| (!f.getName().endsWith("jar") && !f.getName().endsWith("class"))) {
continue;
}
if (GENERATED_CLASSES_JAR.equals(f.getName())) {
continue;
}
if (f.getName().endsWith("class")) {
typeGraph.addNode(f);
openClassFiles.put(path, f);
} else {
JarFile jar = new JarFile(path);
openJarFiles.put(path, jar);
java.util.Enumeration<JarEntry> entriesEnum = jar.entries();
while (entriesEnum.hasMoreElements()) {
final java.util.jar.JarEntry jarEntry = entriesEnum.nextElement();
String entryName = jarEntry.getName();
if (jarEntry.isDirectory()) {
continue;
}
if (entryName.endsWith("-javadoc.xml")) {
try {
processJavadocXml(jar.getInputStream(jarEntry));
// break;
} catch (Exception ex) {
LOG.warn("Cannot process javadoc {} : ", entryName, ex);
}
} else if (entryName.endsWith(".class")) {
TypeGraph.TypeGraphVertex newNode = typeGraph.addNode(jarEntry, jar);
// check if any visited resources belong to this type
for (Iterator<String> iter = resourceCacheSet.iterator(); iter.hasNext(); ) {
String entry = iter.next();
if (entry.startsWith(entryName.substring(0, entryName.length() - 6))) {
newNode.setHasResource(true);
iter.remove();
}
}
} else {
String className = entryName;
boolean foundClass = false;
// check if this resource belongs to any visited type
while (className.contains("/")) {
className = className.substring(0, className.lastIndexOf('/'));
TypeGraph.TypeGraphVertex tgv = typeGraph.getNode(className.replace('/', '.'));
if (tgv != null) {
tgv.setHasResource(true);
foundClass = true;
break;
}
}
if (!foundClass) {
resourceCacheSet.add(entryName);
}
}
}
}
} catch (IOException ex) {
LOG.warn("Cannot process file {}", f, ex);
}
}
typeGraph.trim();
typeGraph.updatePortTypeInfoInTypeGraph(openJarFiles, openClassFiles);
} finally {
for (Entry<String, JarFile> entry : openJarFiles.entrySet()) {
try {
entry.getValue().close();
} catch (IOException e) {
DTThrowable.wrapIfChecked(e);
}
}
}
}
static {
for (MethodTagType type : MethodTagType.values()) {
TAG_TEXT_MAPPING.put(type.tag, type);
}
}
/**
* Standard constructor.
*
* @param type Type that you are going to be creating and editor for.
* @param readOnly Set to true to create a read-only customizer.
*/
public DynamicCustomizer(Class type, boolean readOnly) {
super(new GridBagLayout());
_readOnly = readOnly;
_type = type;
LabelFieldGBC gbc = new LabelFieldGBC();
try {
BeanInfo info = Introspector.getBeanInfo(type);
// Set up pretty display stuff.
setBorder(BorderFactory.createTitledBorder(info.getBeanDescriptor().getDisplayName()));
setToolTipText(info.getBeanDescriptor().getShortDescription());
// Get the properties and sort them.
PropertyDescriptor[] props = info.getPropertyDescriptors();
Arrays.sort(props, new PropertyComparator());
for (int i = 0; i < props.length; i++) {
// Ignore the "class" property, if it is provided.
if (props[i].getName().equals("class")) continue;
// Create a label for the field.
JLabel label = new JLabel(props[i].getDisplayName() + ":");
// Lookup the editor.
PropertyEditor editor = getEditorForProperty(props[i]);
// Add a listener to the editor so we know when to update
// the bean's fields.
editor.addPropertyChangeListener(_eListener);
// XXX What we need to do right here is provide a component
// that makes use of the "paintable" capability of the editor.
Component comp = editor.getCustomEditor();
if (comp == null) {
comp = new JLabel("<No editor available.>");
((JLabel) comp).setBorder(BorderFactory.createEtchedBorder());
}
// See if it is a read-only property. If so, then just
// display it.
if (_readOnly || props[i].getWriteMethod() == null) {
comp.setEnabled(false);
}
// Setup the accellerator key.
label.setLabelFor(comp);
label.setDisplayedMnemonic(label.getText().charAt(0));
// Set the tool tip text, if any.
String tip = props[i].getShortDescription();
if (tip != null) {
label.setToolTipText(tip);
if (comp instanceof JComponent) {
((JComponent) comp).setToolTipText(tip);
}
}
// Add the label and fields.
add(label, gbc.forLabel());
add(comp, gbc.forField());
// Set the mappings between editor and property, etc. for
// quick lookup later.
_prop2Editor.put(props[i], editor);
_editor2Prop.put(editor, props[i]);
}
// Filler...
add(new JLabel(), gbc.forLastLabel());
} catch (Exception ex) {
ex.printStackTrace();
}
}
