Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   * 
   *      http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.log4j.lf5.viewer.categoryexplorer;
 
 
 
CategoryExplorerModel

Author(s):
Michael J. Sikorsky
Robert Shaw
Brent Sprecher
Richard Hurst
 
 
 // Contributed by ThoughtWorks Inc.
 
 public class CategoryExplorerModel extends DefaultTreeModel {
   private static final long serialVersionUID = -3413887384316015901L;
 
   //--------------------------------------------------------------------------
   //   Constants:
   //--------------------------------------------------------------------------
 
   //--------------------------------------------------------------------------
   //   Protected Variables:
   //--------------------------------------------------------------------------
 
   protected boolean _renderFatal = true;
   protected ActionListener _listener = null;
   protected ActionEvent _event = new ActionEvent(this,
       "Nodes Selection changed");
 
   //--------------------------------------------------------------------------
   //   Private Variables:
   //--------------------------------------------------------------------------
 
   //--------------------------------------------------------------------------
   //   Constructors:
   //--------------------------------------------------------------------------
 
   public CategoryExplorerModel(CategoryNode node) {
     super(node);
   }
   //--------------------------------------------------------------------------
   //   Public Methods:
   //--------------------------------------------------------------------------
 
   public void addLogRecord(LogRecord lr) {
     CategoryPath path = new CategoryPath(lr.getCategory());
     addCategory(path); // create category path if it is new
     CategoryNode node = getCategoryNode(path);
     node.addRecord(); // update category node
     if ( && lr.isFatal()) {
       TreeNode[] nodes = getPathToRoot(node);
       int len = nodes.length;
       CategoryNode parent;
 
       // i = 0 gives root node
       // skip node and root, loop through "parents" in between
       for (int i = 1; i < len - 1; i++) {
         parent = (CategoryNodenodes[i];
         parent.setHasFatalChildren(true);
         nodeChanged(parent);
       }
       node.setHasFatalRecords(true);
       nodeChanged(node);
     }
   }
 
     return (CategoryNodegetRoot();
   }
 
  public CategoryNode getCategoryNode(String category) {
    CategoryPath path = new CategoryPath(category);
    return (getCategoryNode(path));
  }

  
returns null if no CategoryNode exists.
    CategoryNode root = (CategoryNodegetRoot();
    CategoryNode parent = root// Start condition.
    for (int i = 0; i < path.size(); i++) {
      CategoryElement element = path.categoryElementAt(i);
      // If the two nodes have matching titles they are considered equal.
      Enumeration children = parent.children();
      boolean categoryAlreadyExists = false;
      while (children.hasMoreElements()) {
        CategoryNode node = (CategoryNodechildren.nextElement();
        String title = node.getTitle().toLowerCase();
        String pathLC = element.getTitle().toLowerCase();
        if (title.equals(pathLC)) {
          categoryAlreadyExists = true;
          // This is now the new parent node.
          parent = node;
          break// out of the while, and back to the for().
        }
      }
      if (categoryAlreadyExists == false) {
        return null// Didn't find the Node.
      }
    }
    return (parent);
  }

  

Returns:
true if all the nodes in the specified CategoryPath are selected.
  public boolean isCategoryPathActive(CategoryPath path) {
    CategoryNode root = (CategoryNodegetRoot();
    CategoryNode parent = root// Start condition.
    boolean active = false;
    for (int i = 0; i < path.size(); i++) {
      CategoryElement element = path.categoryElementAt(i);
      // If the two nodes have matching titles they are considered equal.
      Enumeration children = parent.children();
      boolean categoryAlreadyExists = false;
      active = false;
      while (children.hasMoreElements()) {
        CategoryNode node = (CategoryNodechildren.nextElement();
        String title = node.getTitle().toLowerCase();
        String pathLC = element.getTitle().toLowerCase();
        if (title.equals(pathLC)) {
          categoryAlreadyExists = true;
          // This is now the new parent node.
          parent = node;
          if (parent.isSelected()) {
            active = true;
          }
          break// out of the while, and back to the for().
        }
      }
      if (active == false || categoryAlreadyExists == false) {
        return false;
      }
    }
    return (active);
  }


  

Method altered by Richard Hurst such that it returns the CategoryNode corresponding to the CategoryPath

Parameters:
path category path.
Returns:
CategoryNode
    CategoryNode root = (CategoryNodegetRoot();
    CategoryNode parent = root// Start condition.
    for (int i = 0; i < path.size(); i++) {
      CategoryElement element = path.categoryElementAt(i);
      // If the two nodes have matching titles they are considered equal.
      Enumeration children = parent.children();
      boolean categoryAlreadyExists = false;
      while (children.hasMoreElements()) {
        CategoryNode node = (CategoryNodechildren.nextElement();
        String title = node.getTitle().toLowerCase();
        String pathLC = element.getTitle().toLowerCase();
        if (title.equals(pathLC)) {
          categoryAlreadyExists = true;
          // This is now the new parent node.
          parent = node;
          break;
        }
      }
      if (categoryAlreadyExists == false) {
        // We need to add the node.
        CategoryNode newNode = new CategoryNode(element.getTitle());
        //This method of adding a new node cause parent roots to be
        // collapsed.
        //parent.add( newNode );
        //reload(parent);
        // This doesn't force the nodes to collapse.
        insertNodeInto(newNodeparentparent.getChildCount());
        refresh(newNode);
        // The newly added node is now the parent.
        parent = newNode;
      }
    }
    return parent;
  }
  public void update(CategoryNode nodeboolean selected) {
    if (node.isSelected() == selected) {
      return// nothing was changed, nothing to do
    }
    // select parents or deselect children
    if (selected) {
      setParentSelection(nodetrue);
    } else {
      setDescendantSelection(nodefalse);
    }
  }
  public void setDescendantSelection(CategoryNode nodeboolean selected) {
    Enumeration descendants = node.depthFirstEnumeration();
    CategoryNode current;
    while (descendants.hasMoreElements()) {
      current = (CategoryNodedescendants.nextElement();
      // does the current node need to be changed?
      if (current.isSelected() != selected) {
        current.setSelected(selected);
        nodeChanged(current);
      }
    }
  }
  public void setParentSelection(CategoryNode nodeboolean selected) {
    TreeNode[] nodes = getPathToRoot(node);
    int len = nodes.length;
    CategoryNode parent;
    // i = 0 gives root node, i=len-1 gives this node
    // skip the root node
    for (int i = 1; i < leni++) {
      parent = (CategoryNodenodes[i];
      if (parent.isSelected() != selected) {
        parent.setSelected(selected);
        nodeChanged(parent);
      }
    }
  }
  public synchronized void addActionListener(ActionListener l) {
     = AWTEventMulticaster.add(l);
  }
  public synchronized void removeActionListener(ActionListener l) {
     = AWTEventMulticaster.remove(l);
  }
  public void resetAllNodeCounts() {
    CategoryNode current;
    while (nodes.hasMoreElements()) {
      current = (CategoryNodenodes.nextElement();
      current.resetNumberOfContainedRecords();
      nodeChanged(current);
    }
  }

  

Returns the CategoryPath to the specified CategoryNode

Parameters:
node The target CategoryNode
Returns:
CategoryPath
    if (node == null) {
      return null;
    }
    return (new TreePath(getPathToRoot(node)));
  }
  //--------------------------------------------------------------------------
  //   Protected Methods:
  //--------------------------------------------------------------------------
  protected void notifyActionListeners() {
    if ( != null) {
    }
  }

  
Fires a nodechanged event on the SwingThread.
  protected void refresh(final CategoryNode node) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        nodeChanged(node); // remind the tree to render the new node
      }
    });
  }
  //--------------------------------------------------------------------------
  //   Private Methods:
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
  //   Nested Top-Level Classes or Interfaces:
  //--------------------------------------------------------------------------
New to GrepCode? Check out our FAQ X