protected final void doActionPerformed(ActionEvent evt) {
    try {
      ApplicationDiagram diag =
          (ApplicationDiagram) (ApplicationContext.getFocusManager().getFocusObject());
      Point clickPosition = getDiagramLocation(evt);
      if (clickPosition == null)
        clickPosition = GraphicUtil.rectangleGetCenter(diag.getMainView().getViewRect());
      java.awt.Image image = SRSystemClipboard.getClipboardImage();
      if (image == null) return;
      DbObject diagGo = diag.getDiagramGO();
      Db db = diagGo.getDb();

      ImageIcon icon = new ImageIcon(image);
      int imageHeigth = icon.getIconHeight();
      int imageWidth = icon.getIconWidth();

      db.beginTrans(Db.WRITE_TRANS, LocaleMgr.action.getString("pasteDiagramImage"));

      DbObject imageGo = diagGo.createComponent(DbGraphic.fImageGoDiagramImage.getMetaClass());
      imageGo.set(DbGraphic.fImageGoDiagramImage, image);
      imageGo.set(
          DbGraphic.fGraphicalObjectRectangle,
          new Rectangle(
              clickPosition.x - (imageWidth / 2),
              clickPosition.y - (imageHeigth / 2),
              imageWidth,
              imageHeigth));
      db.commitTrans();
    } catch (Exception e) {
      org.modelsphere.jack.util.ExceptionHandler.processUncatchedException(
          ApplicationContext.getDefaultMainFrame(), e);
    }
  }
Ejemplo n.º 2
0
public class Explorer extends DefaultTreeModel implements DbRefreshListener {
  public static final String kUpdate0 = LocaleMgr.screen.getString("Update0");
  private static final Icon kLocalIcon =
      GraphicUtil.loadIcon(ApplicationContext.class, "international/resources/localnode.gif");
  private static final Icon kRepositoryIcon =
      GraphicUtil.loadIcon(ApplicationContext.class, "international/resources/repositorynode.gif");

  public static final String ROOT = "ROOT"; // NOT LOCALIZABLE, property key
  public static final String DB_RAM = "RAM"; // NOT LOCALIZABLE, property key

  private ArrayList tooltipsFields = new ArrayList();

  class PreferencesListener implements PropertyChangeListener {
    public void propertyChange(PropertyChangeEvent evt) {
      try {
        Explorer.this.refresh();
      } catch (Exception e) {
        ExceptionHandler.processUncatchedException(ApplicationContext.getDefaultMainFrame(), e);
      }
    }
  }

  class DbsListener implements DbListener {
    public void dbCreated(Db db) {
      try {
        if (db instanceof DbRAM) {
          Explorer.this.refresh();
        } else {
          Explorer.this.reloadAll();
        }
      } catch (Exception e) {
        ExceptionHandler.processUncatchedException(ApplicationContext.getDefaultMainFrame(), e);
      }
    }

    public void dbTerminated(Db db) {
      try {
        Explorer.this.refresh();
      } catch (Exception e) {
        ExceptionHandler.processUncatchedException(ApplicationContext.getDefaultMainFrame(), e);
      }
    }
  }

  private DbsListener dbslistener = new DbsListener();

  public Explorer() {
    super(new DynamicNode(ROOT));
    PropertiesSet preferences = PropertiesManager.getPreferencePropertiesSet();
    if (preferences != null) {
      preferences.addPrefixPropertyChangeListener(
          DisplayToolTipsOptionGroup.class,
          DisplayToolTipsOptionGroup.TOOLTIPS_FIELD_VISIBILITY_PREFIX,
          new PreferencesListener());
      Db.addDbListener(dbslistener);
      tooltipsFields.addAll(Arrays.asList(DisplayToolTipsOptionGroup.getAvailableMetaFields()));
    }
  }

  public final void showContent() {
    setRoot(createRootNode());
    installDbListeners(true);
  }

  public final void hideContent() {
    setRoot(new DynamicNode(ROOT));
    installDbListeners(false);
  }

  // Overridden
  public void installDbListeners(boolean install) {
    MetaField[] tipsFields = DisplayToolTipsOptionGroup.getAvailableMetaFields();
    MetaField[] metaFields = new MetaField[] {DbObject.fComponents, DbSemanticalObject.fName};
    if (install) {
      MetaField.addDbRefreshListener(this, null, metaFields);
      MetaField.addDbRefreshListener(this, null, tipsFields);
    } else {
      MetaField.removeDbRefreshListener(this, metaFields);
      MetaField.removeDbRefreshListener(this, tipsFields);
    }
  }

  /**
   * If CS application, create a root node with 2 subnodes: RAM and repository; the RAM subnode
   * contains the list of RAM projects as subnodes. If RAM application, create a root node with the
   * list of projects as subnodes.
   */
  private DynamicNode createRootNode() {
    DynamicNode rootNode = null;
    DynamicNode RAMNode = null;
    try {
      RAMNode = new DynamicNode(DB_RAM);
      RAMNode.setDisplayText(DbRAM.DISPLAY_NAME);
      RAMNode.setIcon(kLocalIcon);
      loadChildren(RAMNode);
      Db[] dbs = Db.getDbs();
      for (int i = 0; i < dbs.length; i++) {
        if (dbs[i] instanceof DbRAM) continue;
        if (rootNode == null) {
          rootNode = new DynamicNode(ROOT);
          rootNode.setHasLoaded();
          rootNode.add(RAMNode);
        }
        DynamicNode dbNode = new DynamicNode(dbs[i]);
        dbNode.setDisplayText(dbs[i].getDBMSName());
        dbNode.setIcon(kRepositoryIcon);
        rootNode.add(dbNode);
        loadChildren(dbNode);
      }
    } catch (DbException ex) {
      org.modelsphere.jack.util.ExceptionHandler.processUncatchedException(
          ApplicationContext.getDefaultMainFrame(), ex);
    }
    return (rootNode != null ? rootNode : RAMNode);
  }

  protected final DynamicNode createNode(DbObject dbParent, DbObject dbo) throws DbException {
    return (dbParent == getDbParent(dbo, Db.NEW_VALUE)
        ? createPrimaryNode(dbParent, dbo)
        : createSecondaryNode(dbParent, dbo));
  }

  // Overridden
  protected DynamicNode createPrimaryNode(DbObject dbParent, DbObject dbo) throws DbException {
    DynamicNode node = new DynamicNode(dbo, getSequence(dbParent, dbo));
    String displayText = getDisplayText(dbParent, dbo);
    String editText = getEditText(dbParent, dbo);
    String tooltips = getToolTipsText(dbParent, dbo);
    node.setDisplayText(displayText, editText);
    node.setToolTips(tooltips);
    node.setIcon(getIcon(dbo));
    node.setGroupParams(getGroupParams(dbParent, dbo));
    node.setIsLeaf(isLeaf(dbParent, dbo));
    node.setDefaultAction(getDefaultAction(dbo));
    return node;
  }

  // Overridden
  protected DynamicNode createSecondaryNode(DbObject dbParent, DbObject dbo) throws DbException {
    DynamicNode primNode = getDynamicNode(dbo, true);
    DynamicNode node = new DynamicNode(primNode, primNode.insertIndex);
    node.setGroupParams(getGroupParams(dbParent, dbo));
    node.setDefaultAction(getDefaultAction(dbo));
    return node;
  }

  protected String getDisplayText(DbObject dbParent, DbObject dbo) throws DbException {
    return ApplicationContext.getSemanticalModel().getDisplayText(dbo, Explorer.class);
  }

  protected String getToolTipsText(DbObject dbParent, DbObject dbo) throws DbException {
    return ToolTipsServices.getToolTips(dbo, Explorer.class);
  }

  protected String getEditText(DbObject dbParent, DbObject dbo) throws DbException {
    MetaField editableMetafield = getEditableMetaField(dbo);
    String editText = null;
    if (editableMetafield == null) editText = dbo.getName();
    else editText = (String) dbo.get(editableMetafield);
    return editText == null ? "" : editText;
  }

  protected int getSequence(DbObject dbParent, DbObject dbo) throws DbException {
    return dbParent.getComponents().indexOf(dbo);
  }

  // Overridden
  protected GroupParams getGroupParams(DbObject dbParent, DbObject dbo) throws DbException {
    return GroupParams.defaultGroupParams;
  }

  /*
   * Specifies an action to activate on double click. Beware that it must not conflict with the
   * default double click behavior of JTree (expand, collapse). Recommanded to avoid returning an
   * action for a 'not leaf' object.
   */
  protected AbstractApplicationAction getDefaultAction(DbObject dbo) throws DbException {
    return null;
  }

  // Overridden
  protected boolean isLeaf(DbObject dbParent, DbObject dbo) throws DbException {
    return false;
  }

  // Overridden
  protected boolean isContainerRoot(Object object) {
    return false;
  }

  protected final void loadChildren(DynamicNode node) throws DbException {
    if (node.hasLoaded() || node.isLeaf()) return;
    node.setHasLoaded();
    Object userObject = node.getUserObject();
    if (userObject == ROOT) return;
    SrVector children = new SrVector(10);
    boolean isSorted = true;
    DbObject dbParent = null;
    if (userObject == DB_RAM) {
      Db[] dbs = Db.getDbs();
      for (int i = 0; i < dbs.length; i++) {
        if (dbs[i] instanceof DbRAM) insertProjects(children, dbs[i]);
      }
    } else if (userObject instanceof Db) {
      insertProjects(children, (Db) userObject);
    } else {
      dbParent = (DbObject) userObject;
      dbParent.getDb().beginTrans(Db.READ_TRANS);
      insertComponents(children, dbParent);
      isSorted = childrenAreSorted(dbParent);
      dbParent.getDb().commitTrans();
    }

    if (isSorted) {
      children.sort(getComparator(dbParent));
    }

    ArrayList groupNodeList = new ArrayList();
    DynamicNode groupNode = null;
    Enumeration enumeration = children.elements();
    while (enumeration.hasMoreElements()) {
      DynamicNode childNode = (DynamicNode) enumeration.nextElement();
      GroupParams group = childNode.getGroupParams();
      if (group.name == null) {
        node.add(childNode);
      } else {
        if (groupNode == null) {
          groupNode = createGroupNode(group);
          node.add(groupNode);
          groupNodeList.add(groupNode);
        } else if (!groupNode.toString().equals(group.name)) {
          boolean groupFound = false;
          for (int i = 0; i < groupNodeList.size(); i++) {
            groupNode = (DynamicNode) groupNodeList.get(i);
            if (groupNode.toString().equals(group.name)) {
              groupFound = true;
              break;
            }
          }
          if (!groupFound) {
            groupNode = createGroupNode(group);
            node.add(groupNode);
            groupNodeList.add(groupNode);
          }
        }
        groupNode.add(childNode);
      }
    }
    groupNodeList.clear();
  }

  private DynamicNode createGroupNode(GroupParams group) {
    DynamicNode groupNode = new DynamicNode(group);
    groupNode.setDisplayText(group.name);
    groupNode.setIcon(group.icon);
    groupNode.setGroupParams(group);
    groupNode.setHasLoaded();
    return groupNode;
  }

  private void insertProjects(SrVector children, Db db) throws DbException {
    db.beginTrans(Db.READ_TRANS);
    DbObject parent = db.getRoot();
    DbEnumeration dbEnum = parent.getComponents().elements(DbProject.metaClass);
    while (dbEnum.hasMoreElements())
      children.addElement(createPrimaryNode(parent, dbEnum.nextElement()));
    dbEnum.close();
    db.commitTrans();
  }

  // Overridden
  protected void insertComponents(SrVector children, DbObject dbParent) throws DbException {
    SemanticalModel model = ApplicationContext.getSemanticalModel();

    DbEnumeration dbEnum = dbParent.getComponents().elements();
    while (dbEnum.hasMoreElements()) {
      DbObject dbo = dbEnum.nextElement();
      boolean isVisible = model.isVisibleOnScreen(dbParent, dbo, Explorer.class);
      if (isVisible) {
        children.addElement(createPrimaryNode(dbParent, dbo));
      } // end if
    } // end while
    dbEnum.close();
  } // end insertComponents()

  // Rebuilds the hierarchy of loaded nodes.
  public final void refresh() throws DbException {
    refresh((DynamicNode) getRoot());
  }

  // Reload all
  // Use this method instead of refresh() if refresh() doesn't work.
  public final void reloadAll() throws DbException {
    setRoot(createRootNode());
  }

  protected final void refresh(DynamicNode parentNode) throws DbException {
    if (ApplicationContext.getFocusManager().isGuiLocked()) return;

    if (parentNode == null) return;
    if (!parentNode.hasLoaded() || parentNode.isLeaf()) {
      if (parentNode.getUserObject() instanceof DbObject)
        updateNode((DbObject) parentNode.getUserObject());
      return;
    }
    Object userObject = parentNode.getUserObject();
    if (userObject == ROOT) {
      int count = getChildCount(parentNode);
      for (int i = 0; i < count; i++) {
        DynamicNode node = (DynamicNode) getChild(parentNode, i);
        userObject = node.getUserObject();
        if (userObject == DB_RAM) refresh(node);
        else {
          if (((Db) userObject).isValid()) {
            ((Db) userObject).beginTrans(Db.READ_TRANS);
            refresh(node);
            ((Db) userObject).commitTrans();
          } else {
            removeNode(node);
          }
        }
      }
      return;
    }
    if (userObject == DB_RAM) {
      int count = getChildCount(parentNode);
      for (int i = count - 1; i >= 0; i--) {
        DynamicNode node = (DynamicNode) getChild(parentNode, i);
        Db db = ((DbObject) node.getUserObject()).getDb();
        if (!db.isValid()) {
          removeNode(node);
          continue;
        }
        db.beginTrans(Db.READ_TRANS);
        refresh(node);
        // refresh the display text for the projects - we do not want to
        // apply a full update
        // using update(dbo) because we want to preserve the expanded
        // state for projects.
        node.setDisplayText(getDisplayText(null, (DbObject) node.getUserObject()));
        db.commitTrans();
      }
      // check for missing Db
      Db[] dbs = Db.getDbs();
      for (int i = 0; i < dbs.length; i++) {
        if (!dbs[i].isValid() || !(dbs[i] instanceof DbRAM)) continue;
        DynamicNode dbNode = getDynamicNode(parentNode, dbs[i], 0);
        if (dbNode != null) continue;
        dbs[i].beginTrans(Db.READ_TRANS);
        DbEnumeration dbEnum = dbs[i].getRoot().getComponents().elements(DbProject.metaClass);
        if (dbEnum.hasMoreElements()) {
          getDynamicNode(dbEnum.nextElement(), false);
        }
        dbEnum.close();
        dbs[i].commitTrans();
      }
      return;
    }

    SrVector children = new SrVector(10);
    if (userObject instanceof Db) {
      insertProjects(children, (Db) userObject);
      children.sort();
    } else if (((DbObject) userObject).isAlive()) {
      insertComponents(children, (DbObject) userObject);
      if (childrenAreSorted((DbObject) userObject))
        children.sort(getComparator((DbObject) userObject));
    }

    DynamicNode groupNode = null;
    int index = 0;
    int iGroup = 0;
    for (int i = 0; i < children.size(); i++) {
      DynamicNode srcNode = (DynamicNode) children.elementAt(i);
      GroupParams group = srcNode.getGroupParams();
      if (group.name == null) {
        refreshNode(srcNode, parentNode, index);
        index++;
      } else {
        if (groupNode == null || !groupNode.toString().equals(group.name)) {
          if (groupNode != null) deleteNodes(groupNode, iGroup);
          groupNode = getGroupNode(parentNode, group, index);
          if (groupNode == null) {
            groupNode = createGroupNode(group);
            insertNodeInto(groupNode, parentNode, index);
          } else if (groupNode != getChild(parentNode, index)) {
            removeNodeFromParent(groupNode);
            insertNodeInto(groupNode, parentNode, index);
          }
          index++;
          iGroup = 0;
        }
        refreshNode(srcNode, groupNode, iGroup);
        iGroup++;
      }
    }
    if (groupNode != null) deleteNodes(groupNode, iGroup);
    deleteNodes(parentNode, index);

    // Refresh subnodes in a separate pass to avoid interference from
    // automatic
    // adding of a primary node when adding a secondary node.
    refreshChildren(parentNode);
  }

  private void refreshNode(DynamicNode srcNode, DynamicNode parentNode, int index)
      throws DbException {
    DynamicNode dstNode = getDynamicNode(parentNode, srcNode.getUserObject(), index);
    if (dstNode == null) {
      insertNodeInto(srcNode, parentNode, index);
    } else {
      if (dstNode != getChild(parentNode, index)) {
        removeNodeFromParent(dstNode);
        insertNodeInto(dstNode, parentNode, index);
      }
      if (dstNode.getUserObject() instanceof DynamicNode) {
        nodeChanged(dstNode); // in case text of primary node has
        // changed
      } else if (!dstNode.toString().equals(srcNode.toString())
          || dstNode.getIcon() != srcNode.getIcon()
          || (dstNode.getToolTips() != null
              && !dstNode.getToolTips().equals(srcNode.getToolTips()))) {
        dstNode.setDisplayText(srcNode.toString(), srcNode.getEditText());
        dstNode.setIcon(srcNode.getIcon());
        dstNode.setToolTips(srcNode.getToolTips());
        nodeChanged(dstNode);
      }
    }
  }

  private void deleteNodes(DynamicNode parentNode, int iStart) {
    while (iStart < getChildCount(parentNode))
      removeNodeFromParent((DynamicNode) getChild(parentNode, iStart));
  }

  protected final void refreshChildren(DynamicNode parentNode) throws DbException {
    int count = getChildCount(parentNode);
    for (int i = 0; i < count; i++) {
      DynamicNode node = (DynamicNode) getChild(parentNode, i);
      if (node.getUserObject() instanceof GroupParams) refreshChildren(node);
      else refresh(node);
    }
  }

  private DynamicNode getGroupNode(DynamicNode parentNode, GroupParams group, int iStart) {
    DynamicNode nodeFound = null;
    int count = getChildCount(parentNode);
    for (int i = iStart; i < count; i++) {
      DynamicNode node = (DynamicNode) getChild(parentNode, i);
      if (node.getUserObject() instanceof GroupParams && node.toString().equals(group.name)) {
        nodeFound = node;
        break;
      }
    }
    return nodeFound;
  }

  /*
   * Search an object in the whole tree. For optimization, we build the inverse path of <dbo>
   * (from the child node to the root node), by getting the information from the database. Then,
   * instead of scanning the whole tree, we just follow the path obtained from the database. This
   * way, we always find a primary node (anyway if a secondary node exists, its primary node
   * necessarily exists).
   */
  public final DynamicNode getDynamicNode(DbObject dbo, boolean load) throws DbException {
    return getDynamicNode(dbo, Db.NEW_VALUE, load);
  }

  public final DynamicNode getDynamicNode(DbObject dbo, int which, boolean load)
      throws DbException {
    SrVector path = new SrVector(10);
    Db db = dbo.getDb();
    db.beginTrans(Db.READ_TRANS);
    while (dbo != null && !(dbo instanceof DbRoot)) {
      path.addElement(dbo);
      dbo = getDbParent(dbo, which);
    }
    if (db instanceof DbRAM) {
      if (DB_RAM != ((DynamicNode) getRoot()).getUserObject()) path.addElement(DB_RAM);
    } else path.addElement(db);

    DynamicNode nodeFound = (DynamicNode) getRoot();
    for (int i = path.size(); --i >= 0; ) {
      if (load) loadChildren(nodeFound);
      Object userObj = path.elementAt(i);
      dbo = null;
      DbObject dbParent = null;
      GroupParams group = GroupParams.defaultGroupParams;
      DynamicNode groupNode = null;
      DynamicNode node = null;
      if (userObj instanceof DbObject) {
        dbo = (DbObject) userObj;
        dbParent = getDbParent(dbo, which);
        group = getGroupParams(dbParent, dbo);
      }
      if (group.name == null) {
        node = getDynamicNode(nodeFound, userObj, 0);
      } else {
        groupNode = getGroupNode(nodeFound, group, 0);
        if (groupNode != null) node = getDynamicNode(groupNode, userObj, 0);
      }
      if (node == null && nodeFound.hasLoaded() && !nodeFound.isLeaf() && which == Db.NEW_VALUE) {

        SemanticalModel model = ApplicationContext.getSemanticalModel();
        boolean visible = model.isVisibleOnScreen(dbParent, dbo, Explorer.class);

        if (visible) {
          node = createPrimaryNode(dbParent, dbo);
          if (group.name == null) {
            insertNodeInto(node, nodeFound, getInsertionIndex(dbParent, dbo, nodeFound, node));
          } else {
            if (groupNode == null) {
              groupNode = createGroupNode(group);
              insertNodeInto(groupNode, nodeFound, getSortedIndex(nodeFound, groupNode));
            }
            insertNodeInto(node, groupNode, getInsertionIndex(dbParent, dbo, groupNode, node));
          }
        }
      }
      nodeFound = node;
      if (nodeFound == null) break;
    }
    db.commitTrans();
    return nodeFound;
  }

  private DynamicNode getDynamicNode(DynamicNode parentNode, Object userObj, int iStart)
      throws DbException {
    DynamicNode nodeFound = null;
    int count = getChildCount(parentNode);
    for (int i = iStart; i < count; i++) {
      DynamicNode node = (DynamicNode) getChild(parentNode, i);
      if (node.getUserObject() == userObj) {
        nodeFound = node;
        break;
      }
    }
    return nodeFound;
  }

  // The value type for the returned MetaField MUST be String.
  // Default will use getName and setName defined on DbObject
  protected MetaField getEditableMetaField(DbObject dbo) {
    return null;
  }

  // Called at the end of a cell edition, to process the edition result.
  public final void valueForPathChanged(TreePath path, Object newValue) {
    DynamicNode node = (DynamicNode) path.getLastPathComponent();
    Object obj = node.getRealObject();
    if (obj instanceof DbObject) {
      boolean editable = false;
      try {
        Db db = ((DbObject) obj).getDb();
        if (db.isValid()) {
          db.beginReadTrans();
          MetaField editableMetaField = getEditableMetaField((DbObject) obj);
          if (editableMetaField == null)
            editable =
                ApplicationContext.getSemanticalModel()
                    .isNameEditable((DbObject) obj, Explorer.class);
          else
            editable =
                ApplicationContext.getSemanticalModel()
                    .isEditable(editableMetaField, (DbObject) obj, Explorer.class);
          db.commitTrans();
        }
      } catch (DbException ex) {
        org.modelsphere.jack.util.ExceptionHandler.processUncatchedException(
            ApplicationContext.getDefaultMainFrame(), ex);
        editable = false;
      }
      if (!editable) return;
    } else {
      return;
    }
    DbObject semObj = (DbObject) obj;
    try {
      MetaField editableMetaField = getEditableMetaField(semObj);
      String transName =
          (editableMetaField == null
              ? LocaleMgr.action.getString("rename")
              : MessageFormat.format(kUpdate0, new Object[] {editableMetaField.getGUIName()}));
      semObj.getDb().beginTrans(Db.WRITE_TRANS, transName);
      if (editableMetaField == null) {
        if (semObj.getTransStatus() == Db.OBJ_REMOVED) return;
        semObj.setName((String) newValue);
      } else semObj.set(editableMetaField, (String) newValue);
      semObj.getDb().commitTrans();
      nodeChanged(node); // in case it is a secondary node (only the
      // primary node is updated by the refresh
      // listener).
    } catch (Exception ex) {
      org.modelsphere.jack.util.ExceptionHandler.processUncatchedException(
          ApplicationContext.getDefaultMainFrame(), ex);
    }
  }

  // ////////////////////////////////////
  // DbRefreshListener SUPPORT
  //
  // Overridden
  public void refreshAfterDbUpdate(DbUpdateEvent evt) throws DbException {
    if (evt.metaField == DbObject.fComponents) { // add, remove, or move to
      // another parent
      if (evt.neighbor instanceof DbGraphicalObjectI) // optimization:
        // discard
        // immediately the
        // graphical objects
        return;
      if (evt.op == Db.REMOVE_FROM_RELN) {
        // DbObject removed or with a new parent: remove the node from
        // its old parent if loaded.
        DynamicNode node = getDynamicNode(evt.neighbor, Db.OLD_VALUE, false);
        if (node != null) removeNode(node);
      } else if (evt.op == Db.ADD_TO_RELN) {
        // DbObject added or with a new parent: if its new parent has
        // its chidren loaded,
        // add a node for the new child.
        getDynamicNode(evt.neighbor, false);
      } else { // Db.REINSERT_IN_RELN
        DynamicNode node = getDynamicNode(evt.neighbor, false);
        if ((node != null && !childrenAreSorted(evt.dbo))
            || (node != null && !node.getGroupParams().sorted)) {
          DynamicNode parentNode = (DynamicNode) node.getParent();
          updateInsertIndexInChildrenOfNode(parentNode);
          removeNodeFromParent(node);
          int index = getInsertionIndex(evt.dbo, evt.neighbor, parentNode, node);
          insertNodeInto(node, parentNode, index);
        }
      }
    }
    // name refresh
    else if (evt.metaField == DbSemanticalObject.fName || tooltipsFields.contains(evt.metaField)) {
      updateNode(evt.dbo);
    }
  }

  //
  // End of DbRefreshListener SUPPORT
  // ////////////////////////////////////

  protected final void updateInsertIndexInChildrenOfNode(DynamicNode parentNode)
      throws DbException {
    Enumeration childrenEnum = parentNode.children();
    while (childrenEnum.hasMoreElements()) {
      DynamicNode node = (DynamicNode) childrenEnum.nextElement();
      DbObject dbo = (DbObject) node.getRealObject();
      DbObject dbParent = dbo.getComposite();
      node.insertIndex = getSequence(dbParent, dbo);
    }
  }

  // Remove the group node if this node is the last of its group.
  protected final void removeNode(DynamicNode node) {
    DynamicNode parentNode = (DynamicNode) node.getParent();
    if (parentNode.getUserObject() instanceof GroupParams && getChildCount(parentNode) == 1)
      removeNodeFromParent(parentNode);
    else removeNodeFromParent(node);
  }

  // This method refreshes the display text of a node.
  protected final void updateNode(DbObject dbo) throws DbException {
    DynamicNode node = getDynamicNode(dbo, false);
    if (node == null) return;

    // backup selection and restore later
    Object focusObject = ApplicationContext.getFocusManager().getFocusObject();
    TreePath[] selPaths = null;
    if (focusObject instanceof ExplorerView) {
      selPaths = ((ExplorerView) focusObject).getSelectionPaths();
    }

    String displayText = getDisplayText(null, dbo);
    String editText = getEditText(null, dbo);
    String toolTipText = getToolTipsText(null, dbo);
    Icon icon = getIcon(dbo);

    node.setDisplayText(displayText, editText);
    node.setToolTips(toolTipText);
    node.setIcon(icon);
    nodeChanged(node);
    DynamicNode parentNode = (DynamicNode) node.getParent();
    Object parent = parentNode.getUserObject();
    if (!(parent instanceof DbObject) || childrenAreSorted((DbObject) parent)) {
      removeNodeFromParent(node);
      int index = getSortedIndex(parentNode, node);
      insertNodeInto(node, parentNode, index);
    }

    // Restore selection
    if (focusObject instanceof ExplorerView && selPaths != null) {
      ExplorerView explorerView = (ExplorerView) focusObject;
      try { // Should not occurs
        explorerView.setSelectionPaths(selPaths);
      } catch (Exception e) {
        explorerView.setSelectionPaths(new TreePath[] {});
      }
    }
  }

  // This method updates the explorer for changes in a relation N where all
  // children are secondary nodes.
  // IMPORTANT: a node whose children are secondary nodes cannot have grouping
  // nodes.
  protected final void updateSecondaryChildren(DbUpdateEvent evt) throws DbException {
    if (!ApplicationContext.getSemanticalModel()
        .isVisibleOnScreen(evt.dbo, evt.neighbor, Explorer.class)) return;
    DynamicNode parentNode = getDynamicNode(evt.dbo, false);
    if (parentNode == null || !parentNode.hasLoaded()) return;
    DynamicNode childNode = null;
    int nb = getChildCount(parentNode);
    for (int i = 0; i < nb; i++) {
      DynamicNode node = (DynamicNode) getChild(parentNode, i);
      if (((DynamicNode) node.getUserObject()).getUserObject() == evt.neighbor) {
        childNode = node;
        break;
      }
    }
    if (evt.op == Db.REMOVE_FROM_RELN) {
      if (childNode != null) removeNodeFromParent(childNode);
    } else if (evt.op == Db.ADD_TO_RELN) {
      if (childNode == null) {
        childNode = createSecondaryNode(evt.dbo, evt.neighbor);
        int index = getInsertionIndex(evt.dbo, evt.neighbor, parentNode, childNode);
        insertNodeInto(childNode, parentNode, index);
      }
    } else { // Db.REINSERT_IN_RELN
      if (!childrenAreSorted(evt.dbo) && childNode != null) {
        removeNodeFromParent(childNode);
        int index = getInsertionIndex(evt.dbo, evt.neighbor, parentNode, childNode);
        insertNodeInto(childNode, parentNode, index);
      }
    }
  }

  protected final int getInsertionIndex(
      DbObject dbParent, DbObject dbo, DynamicNode parentNode, DynamicNode node)
      throws DbException {
    if (childrenAreSorted(dbParent)) return getSortedIndex(parentNode, node);
    return Math.max(0, Math.min(getIndex(dbParent, dbo), getChildCount(parentNode)));
  }

  // Proceed by binary search because comparison may be long.
  protected final int getSortedIndex(DynamicNode parentNode, DynamicNode childNode) {
    int lo = -1;
    int hi = getChildCount(parentNode);
    while (lo + 1 != hi) {
      int mid = (lo + hi) / 2;
      DynamicNode node = (DynamicNode) getChild(parentNode, mid);
      if (childNode.compareTo(node) < 0) hi = mid;
      else lo = mid;
    }
    return hi;
  }

  // Overridden
  protected boolean childrenAreSorted(DbObject dbo) throws DbException {
    return true;
  }

  // Override to provide a custom Comparator.
  // If null, a default Comparator will be used.
  // parent may be null.
  // Note, this one should be moved in the group (providing a GUI name for
  // each available comparators for the group
  // and an option, may be an Action, for user selection of the comparator)
  protected Comparator getComparator(DbObject parent) throws DbException {
    return null;
  }

  protected Icon getIcon(DbObject dbo) throws DbException {
    return dbo.getSemanticalIcon(DbObject.SHORT_FORM);
  }

  // Must return the index in the children list if childrenAreSorted(dbParent)
  // returns false.
  // Overridden
  protected int getIndex(DbObject dbParent, DbObject dbo) throws DbException {
    return dbParent.getComponents().indexOf(dbo);
  }

  // Overridden
  protected DbObject getDbParent(DbObject dbo, int which) throws DbException {
    return (DbObject) dbo.get(DbObject.fComposite, which);
  }
}