/** * Clear out all the old editors, and get new editors corresponding to the new object classes. * * @param entry the entry to be displayed by all the editors * @param ds the datasource the editors may use for more info * @param ocs the object classes (in order) to find editors for. */ protected void setEditors(DXEntry entry, DataBrokerQueryInterface ds, Vector ocs) { try { clearPluggableEditors(); // clear all extra editors // search for unique structural editors... if ("false".equalsIgnoreCase(JXConfig.getProperty("plugins.ignoreUniqueness"))) { if (ocs == null) // TE: may happen if virtual entry. return; int size = ocs.size(); for (int i = 0; i < size; i++) { Object objectClass = ocs.get(i); if (objectClass != null) { PluggableEditor ed = getEditor(objectClass.toString()); if (ed != null && ed.isUnique() == true) // found a unique editor { // so clear old ones, addUniqueEditor(ed); // and use the unique one refreshEditors(entry, ds); // to display the data setCurrentEditor(ed); return; // ... and exit. } } } } else log.warning("skipping uniqueness test for pluggable editors"); boolean newEdSet = false; // search for non-unique structural editors for (int i = 0; i < ocs.size(); i++) { Object objectClass = ocs.get(i); if (objectClass != null) { PluggableEditor ed = getEditor(objectClass.toString()); if (ed != null) { addEditor(ed); // Force the displayed editor to be the first pluggable one... if (newEdSet == false) { setCurrentEditor(ed); newEdSet = true; } } } } // search for non-structural editors try { Attribute allOCs = entry.getAllObjectClasses(); if (allOCs != null) { Enumeration vals = allOCs.getAll(); while (vals.hasMoreElements()) { Object oc = vals.nextElement(); if (oc != null) { String ocName = oc.toString(); if (ocs.contains(ocName) == false) // don't bother with struct objectclasses dealt with above { PluggableEditor ed = getEditor(ocName); if (ed != null) { addEditor(ed); if (ed.isUnique()) // a special service to users... log.warning( "WARNING: Illegal unique editor defined for oc: " + ocName + " not allowed - (oc not in primary structural inheritance chain)"); } } } } } } catch (NamingException e) { log.log( Level.WARNING, "WARNING: non-fatal exception getting object classes for plugin editors. ", e); } addEditor(templateDisplay); // and always add old faithfulls... // XXX if (entry.getStatus() != DXEntry.NEW) // well, almost always... addEditor(tableDisplay); } catch (Exception e) { log.warning("Unexpected Exception in AttributeDisplay\n" + e); e.printStackTrace(); } }
public void displayEntry(DXEntry dxentry, DataBrokerQueryInterface ds) { // Set the local data variables. dataSource = ds; entry = dxentry; // check that the default editors have been initialised. if (tableDisplay == null) initTableEditor(); if (templateDisplay == null) initHTMLEditor(); // check for a 'no data' display - if there is no data, revert // to the default html 'no data' template. if (entry == null) // || entry.size() == 0) //TE: This is commented out to allow virtual nodes to be // edited. { if (oldOCSig != null) { clearPluggableEditors(); if (activeEditors.size() == 0) { addEditor(templateDisplay); } oldOCSig = null; } refreshEditors(null, ds); } else { dataSource = ds; // may be null... Vector ocs = entry.getOrderedOCs(); // try to create a unique 'signature' for a group of object classes // This relies on them being delivered in the same order though. (Less // efficient if they aren't, but otherwise shouldn't be a big problem). String newOCSig = new String(); if (ocs != null) for (int i = 0; i < ocs.size(); i++) { Object ocSig = ocs.get(i); if (ocSig != null) newOCSig += ocSig.toString(); } // Check if signiture hasn't changed. If it *has* changed, // reset the editors using 'setEditors', and update // the 'old object class signiture' variable. if (newOCSig.equals(oldOCSig) == false) { setEditors(entry, ds, ocs); oldOCSig = newOCSig; } // Some quick sanity checks... if (entry.getStatus() == DXEntry.NEW) // check for new entries (but *not* NEW_WRITTEN)... { // don't allow editors to appear that can't edit a new entry trimNonNewEntryEditors(); suggestPluggableEditor(); } else { // make sure that the html template display is around... // XXX (a bit of a hack - this should really check that *all* // XXX editor that can't handle new entries have been added back... // XXX (maybe set flag?) // TE: added '&& !currentEditor.isUnique()' b/c this code always made sure the HTML // TE: editor is visible, whereas with a unique plugin we only want that one visible... // TE: unless of course I am totally confused! See bug 674. if (activeEditors.contains(templateDisplay) == false && !currentEditor.isUnique()) { add((PluggableEditor) templateDisplay, 0); if (currentEditor != null) // XXX hack hack. setCurrentEditor(currentEditor); } } if (activeEditors.contains(currentEditor) == false) { suggestPluggableEditor(); } // now that the editor set we're using has been sorted out, // actually go and update the editors! (Nb. this triggers an usaved changes check) refreshEditors(entry, ds); } }