/**
   * The constructor for AttributeDisplay requires information about default file directories and
   * urls. These are passed in via a Properties object, that should contain values for
   * 'dir.templates', 'dir.htmldocs', and 'dir.local'.
   *
   * @param owner the parent frame, used for gui sanity and L&F propogation
   * @param resourceLoader the resource loader used to load HTML templates from zip/jar files
   */
  public AttributeDisplay(JFrame owner, CBResourceLoader resourceLoader) {
    super();

    // myProperties = props;

    if (JXConfig.getProperty("plugins.package") != null) {
      setPackagePrefix(JXConfig.getProperty("plugins.package"));
      log.fine("SETTING PLUGIN PREFIX TO: " + PACKAGEPREFIX);
    } else log.fine("PLUGIN PREFIX UNCHANGED: " + PACKAGEPREFIX);

    this.resourceLoader = resourceLoader;

    this.owner = owner;

    initHTMLEditor();
    initTableEditor();
    addEditor(templateDisplay);

    /**
     * This change listener is *intended* to listen for user initiated tab changes, rather than
     * programmatic changes to the editor tabs (which are expected to look after themselves)
     */
    addChangeListener(
        new ChangeListener() {
          public void stateChanged(ChangeEvent e) {
            if (ignoreChangeEvents) // sometimes when we're messing around we can fire heaps of
            return; // change events - and there's no point paying attention to 'em.

            int index = getSelectedIndex();

            if (index >= 0 && activeEditors.size() > index && activeEditors.get(index) != null) {
              setCurrentEditor((PluggableEditor) activeEditors.get(index));
            } else // should never happen (ROTFL)
            {
              log.warning(
                  "internal error - unable to find editor # " + index + " in Attribute Display");
            }
          }
        });
  }
  /**
   * 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();
    }
  }