private void updateDescriptorReferencesCore () { for (TimedWeakReference reference : uid2components.values ()) { DesignComponent component = reference.get (); if (component == null) continue; ComponentDescriptor descriptor = descriptorRegistry.getComponentDescriptor (component.getType ()); component.setComponentDescriptor (descriptor, true); } }
public void run() { producers.addAll(registry.getComponentProducers()); } });
private static Map<String,ComponentDescriptor> resolveRegistryMap (Project project) { final DescriptorRegistry registry = DescriptorRegistry.getDescriptorRegistry (MidpDocumentSupport.PROJECT_TYPE_MIDP, ProjectUtils.getProjectID (project)); final HashMap<String, ComponentDescriptor> registryMap = new HashMap<String, ComponentDescriptor> (); registry.readAccess (new Runnable() { public void run () { for (ComponentDescriptor descriptor : registry.getComponentDescriptors ()) { TypeID thisType = descriptor.getTypeDescriptor ().getThisType (); String string = thisType.getString (); if (! checkForJavaIdentifierCompliant (string)) continue; if (! registry.isInHierarchy (ClassCD.TYPEID, thisType) || ClassCD.TYPEID.equals (thisType)) continue; registryMap.put (string, descriptor); } } }); return registryMap; }
/** * Checks whether specified superTypeID is super type id of specified derivedTypeID * @param superTypeID the super type id * @param derivedTypeID the possible derived typeid * @return true if the superTypeID is one of super type ids of the derivedTypeID */ public boolean isInHierarchy (TypeID superTypeID, TypeID derivedTypeID) { return isComponentDescriptorCompatibleWithTypeID (superTypeID, getComponentDescriptor (derivedTypeID)); }
/** * Returns component producers for given type. * @param document the document * @param typeID type of searched producers * @return the producers */ public static Collection<ComponentProducer> getComponentProducers(DesignDocument document, TypeID typeID) { Collection<ComponentProducer> producers = new HashSet<ComponentProducer>(); DescriptorRegistry registry = document.getDescriptorRegistry (); for (ComponentProducer producer : registry.getComponentProducers()) { if (registry.isInHierarchy (typeID, producer.getMainComponentTypeID ())) producers.add(producer); } return producers; }
public static boolean isIndexableDataSet(DesignDocument document, TypeID typeID) { DescriptorRegistry registry = document.getDescriptorRegistry(); return registry.isInHierarchy(IndexableDataAbstractSetCD.TYPEID, typeID); }
@Override public void destroy() throws IOException { super.destroy(); DesignDocument document = ActiveDocumentSupport.getDefault().getActiveDocument(); if (document != null) { DataObjectContext context = ProjectUtils.getDataObjectContextForDocument(document); if (context != null) { final ComponentProducer[] producer = new ComponentProducer[1]; final DescriptorRegistry registry = DescriptorRegistry.getDescriptorRegistry(context.getProjectType(), context.getProjectID()); registry.readAccess(new Runnable() { public void run() { List<ComponentProducer> producers = registry.getComponentProducers(); for (ComponentProducer p : producers) { if (p.getProducerID().equals(obj.getProducerID())) { producer[0] = p; break; } } } }); if (producer[0] != null) { registry.removeComponentDescriptor(producer[0].getMainComponentTypeID()); } } } }
public AddActionItem[] getAddActionItems() { List<Action> actions = new ArrayList<Action>(); DesignDocument document = getComponent().getDocument(); for (TypeID type : types) { for (ComponentDescriptor descriptor : document.getDescriptorRegistry().getComponentDescriptors()){ if (getComponent().getDocument().getDescriptorRegistry().isInHierarchy(type, descriptor.getTypeDescriptor().getThisType())) { for (ComponentProducer producer : document.getDescriptorRegistry().getComponentProducers()) { if (producer.getMainComponentTypeID ().equals(descriptor.getTypeDescriptor().getThisType()) && AcceptSupport.isAcceptable(getComponent(), producer, null)) { Boolean isValid = producer.checkValidity(document, true); if (isValid != null && isValid) actions.add(AddActionItem.getInstance(getComponent(), producer)); } } } } } Collections.sort(actions, ACTIONS_COMPARATOR); return actions.toArray( new AddActionItem[actions.size()]); }
/** * Creates an instance of document. * @param documentInterface the documentInterface interface */ public DesignDocument (DocumentInterface documentInterface) { this.documentInterface = documentInterface; descriptorRegistry = DescriptorRegistry.getDescriptorRegistry (documentInterface.getProjectType (), documentInterface.getProjectID ()); listenerManager = new ListenerManager (this); transactionManager = new TransactionManager (this, descriptorRegistry, listenerManager); uid2components = new HashMap<Long, TimedWeakReference> (100); componentIDCounter = 0; selectedComponents = Collections.emptySet (); descriptorRegistry.addRegistryListener (new DescriptorRegistryListener() { public void descriptorRegistryUpdated () { updateDescriptorReferences (); } }); }
/** * Executes a Runnable.run method with read access. * @param runnable the runnable */ public void readAccess (final Runnable runnable) { descriptorRegistry.readAccess (new Runnable() { public void run () { mutex.readAccess (runnable); } }); }
public void run () { for (ComponentDescriptor descriptor : registry.getComponentDescriptors ()) { TypeID thisType = descriptor.getTypeDescriptor ().getThisType (); String string = thisType.getString (); if (! checkForJavaIdentifierCompliant (string)) continue; if (! registry.isInHierarchy (ClassCD.TYPEID, thisType) || ClassCD.TYPEID.equals (thisType)) continue; registryMap.put (string, descriptor); } } });
/** * Checks whether a component descriptor is compatible (descriptor analogy of instanceof operator) with a type id. * Means: Specified component descriptor or its super descriptor has the same type id as the specified one. * @param typeID the type id * @param componentDescriptor the component descriptor * @return true if compatible */ private boolean isComponentDescriptorCompatibleWithTypeID (TypeID typeID, ComponentDescriptor componentDescriptor) { assert isAccess (); if (typeID == null) return false; for (;;) { if (componentDescriptor == null) return false; TypeDescriptor typeDescriptor = componentDescriptor.getTypeDescriptor (); TypeID checked = typeDescriptor.getThisType (); if (checked == null) return false; if (checked.equals (typeID)) return true; componentDescriptor = getComponentDescriptor (typeDescriptor.getSuperType ()); } }
public void activeDocumentChanged(DesignDocument deactivatedDocument, DesignDocument activatedDocument) { if (activatedDocument == null) { return; } DescriptorRegistry currentRegistry = activatedDocument.getDescriptorRegistry(); if (registeredRegistry != currentRegistry) { if (registeredRegistry != null) { registeredRegistry.removeRegistryListener(this); } registeredRegistry = currentRegistry; if (registeredRegistry != null) { registeredRegistry.addRegistryListener(this); } } String oldProjectID; synchronized (this) { oldProjectID = activeProjectID; activeProjectID = activatedDocument.getDocumentInterface().getProjectID(); } boolean isProjectIDChanged = !activeProjectID.equals(oldProjectID); if (isProjectIDChanged) { registerClassPathListener(activatedDocument); } updatePalette(activatedDocument, isProjectIDChanged); }
/** * Returns a component descriptor for a specified type id. * @param componentType the component type id * @return the component descriptor */ public ComponentDescriptor getComponentDescriptor (TypeID componentType) { assert isAccess () : "No Mutex acess"; //NOI18N if (componentType == null) return null; return descriptors.get (componentType); }
DescriptorRegistry getProjectRegistry (String projectID) { assert Debug.isFriend (DescriptorRegistry.class, "getDescriptorRegistry"); // NOI18N synchronized (projectID2projectRegistry) { WeakReference<DescriptorRegistry> ref = projectID2projectRegistry.get (projectID); DescriptorRegistry registry = ref != null ? ref.get () : null; if (registry == null) { registry = new DescriptorRegistry (this); // projectType, projectID); projectID2projectRegistry.put (projectID, new WeakReference<DescriptorRegistry> (registry)); } return registry; } }
public static String getCodeFeatureName(DesignDocument document, final TypeID type, final String propertyName) { DescriptorRegistry registry = document.getDescriptorRegistry(); // if (! connector.getParentComponent().getType())) { // // } if (type == DateFieldCD.TYPEID && propertyName.equals(DateFieldCD.PROP_INPUT_MODE)) { return "DateFieldBindingProvider.FEATURE_INPUTMODE"; //NOI18N } else if (type == DateFieldCD.TYPEID && propertyName.equals(DateFieldCD.PROP_DATE)) { return "new DateFieldBindingProvider.FeatureInputDateTime(false)"; //NIOI18N } else if (type == ImageItemCD.TYPEID && propertyName.equals(ImageItemCD.PROP_IMAGE)) { return "ImageItemBindingProvider.FEATURE_IMAGE"; //NOI18N } else if (registry.isInHierarchy(ItemCD.TYPEID, type) && propertyName.equals(ItemCD.PROP_LABEL)) { return "ItemBindingProvider.FEATURE_LABEL"; //NOI18N } else if (type == StringItemCD.TYPEID && propertyName.equals(StringItemCD.PROP_TEXT)) { return "StringItemBindingProvider.FEATURE_TEXT"; //NOI18N } else if (type == TextFieldCD.TYPEID && propertyName.equals(TextFieldCD.PROP_TEXT)) { return "new TextFieldBindingProvider.FeatureText(false)"; //NOI18N } throw new IllegalArgumentException(); }
/** * Executes a Runnable.run method with write access. * @param runnable the runnable * @return the event id at the end of the write transaction */ public long writeAccess (final Runnable runnable) { final long eventID[] = new long[] { 0 }; descriptorRegistry.readAccess (new Runnable() { public void run () { mutex.writeAccess (new Runnable () { public void run () { writeAccessCore (runnable); eventID[0] = listenerManager.getEventID (); } }); } }); return eventID[0]; }
/** * Returns a list of all registered component producers. * @return the list of all registered component producers */ public List<ComponentProducer> getComponentProducers () { assert isAccess (); return Collections.unmodifiableList (producers); }
synchronized void clean() { if (activeDocument == null || activeDocument.get() == null) { return; } String projectID = activeDocument.get().getDocumentInterface().getProjectID(); String projectType = activeDocument.get().getDocumentInterface().getProjectType(); final DescriptorRegistry registry = DescriptorRegistry.getDescriptorRegistry(projectType, projectID); registry.readAccess(new Runnable() { public void run() { List<ComponentProducer> list = registry.getComponentProducers(); Map<String, ComponentProducer> producers = new HashMap<String, ComponentProducer>(list.size()); for (ComponentProducer producer : list) { producers.put(producer.getProducerID(), producer); } cleanCore(producers); } }); }
private static String createDataSetName(String name, DesignComponent c) { DescriptorRegistry registry = c.getDocument().getDescriptorRegistry(); if (registry.isInHierarchy(IndexableDataAbstractSetCD.TYPEID, c.getType())) { name = name + " " + INDEXABLE; //NOI18N } else if (registry.isInHierarchy(DataSetAbstractCD.TYPEID, c.getType())) { name = name + " " + DATASET; //NOI18N } return name; }