treefactoryimpl.java

来自「Rapla是一个灵活的多用户资源管理系统。它提供的一些功能有：日历GUI」· Java 代码 · 共 636 行 · 第 1/2 页

        //root.add( periods );
        //root.add( categories );


        return new DefaultTreeModel(root);
    }

    class TypeNode extends DefaultMutableTreeNode {
        private static final long serialVersionUID = 1L;
        
        boolean filtered;
        RaplaType type;
        String title;

        TypeNode(RaplaType type, Object userObject, String title) {
            this.type = type;
            this.title = title;
            setUserObject( userObject );
        }

        TypeNode(RaplaType type, Object userObject) {
        	this( type, userObject, null);
        }

        public RaplaType getType() {
            return type;
        }

        public boolean isFiltered() {
            return filtered;
        }

        public void setFiltered(boolean filtered) {
            this.filtered = filtered;
        }

		public Object getTitle() {
			if ( title != null)
			{
				return title;
			} 
			else
			{
				return userObject.toString();
			}
		}
        
        
    }

    public DefaultMutableTreeNode newNamedNode( Named element) {
        return new NamedNode( element);
    }

    public TreeModel createModel(Category category) throws RaplaException {
        return new DefaultTreeModel(new CategoryNode(getI18n().getLocale(),null,category));
    }

    public TreeModel createModelFlat(Named[] element) {
        DefaultMutableTreeNode root = new DefaultMutableTreeNode("");
        for (int i=0; i< element.length; i++) {
            root.add( new NamedNode( element[i]));
        }
        return new DefaultTreeModel(root);
    }

    public TreeToolTipRenderer createTreeToolTipRenderer() {
        return new RaplaTreeToolTipRenderer();
    }

    public TreeCellRenderer createRenderer() {
        return new ComplexTreeCellRenderer();
    }

    static public class CategoryNode extends RecursiveNode implements MutableTreeNode {
        Locale locale ;
        
        public CategoryNode(Locale locale, TreeNode parent,Category category) {
            super(parent,category);
            this.locale = locale;
        }

        protected Category getCategory() {
            return (Category) getUserObject();
        }

        protected Object[] getChildObjects() {
            return getCategory().getCategories();
        }

        protected RecursiveNode createChildNode(Object userObject) {
            return new CategoryNode(locale, this,(Category)userObject);
        }

        public String toString() {
            return getCategory().getName( locale );
        }

        public void insert( MutableTreeNode child, int index ) {  }

        public void remove( int index )  {  }

        public void remove( MutableTreeNode node ) {   }

        public void setUserObject( Object object ) {  }

        public void removeFromParent()
        {
          parent = null;
        }

        public void setParent( MutableTreeNode newParent )
        {
           parent = newParent;

        }
    }


    public class NamedNode extends DefaultMutableTreeNode {
        private static final long serialVersionUID = 1L;
        
        NamedNode(Named obj) {
            super(obj);
        }
        public String toString() {
            Named obj = (Named) getUserObject();
            if (obj != null) {
                return obj.getName(getI18n().getLocale());
            } else {
                return super.toString();
            }
        }
    };


    // TODO this class is a bit of Hack
    class ComplexTreeCellRenderer extends DefaultTreeCellRenderer {
        private static final long serialVersionUID = 1L;
        
        Icon personIcon;
        Icon folderClosedIcon;
        Icon folderOpenIcon;
        Font normalFont;
        Font bigFont;
        Border nonIconBorder = BorderFactory.createEmptyBorder(1,0,1,0);
        Border conflictBorder = BorderFactory.createEmptyBorder(2,0,2,0);
        public ComplexTreeCellRenderer() {
            personIcon = TreeFactoryImpl.this.getIcon("icon.tree.persons");
            //folderClosedIcon = UIManager.getIcon("Tree.closedIcon");
            //folderOpenIcon = UIManager.getIcon("Tree.openIcon");
            folderClosedIcon = getI18n().getIcon("icon.folder");
            folderOpenIcon = getI18n().getIcon("icon.folder");
            normalFont = UIManager.getFont("Tree.font");
            bigFont = normalFont.deriveFont( Font.BOLD, (float) (normalFont.getSize() * 1.2 ));
            setLeafIcon(defaultIcon);

        }

        public void setLeaf(Object object) {
            Icon icon = null;
            if (object instanceof Allocatable) {
                if ( ((Allocatable)object).isPerson())
                {
                    icon = personIcon;
                }
                else
                {
                    icon = defaultIcon;
                }

            } else if (object instanceof DynamicType ){
                DynamicType type = (DynamicType ) object;
                String classificationType = type.getAnnotation( DynamicTypeAnnotations.KEY_CLASSIFICATION_TYPE);
                if ( DynamicTypeAnnotations.VALUE_RESERVATION_CLASSIFICATION.equals( classificationType ) ) 
                {
                    setBorder( conflictBorder );
                } 
                else 
                {
                    icon =folderClosedIcon;
                }
            }
            if ( icon == null) {
                setBorder( nonIconBorder );
            }
            setLeafIcon( icon );
        }

        public Component getTreeCellRendererComponent(JTree tree, Object value,
                                                      boolean sel, boolean expanded,
                                                      boolean leaf,int row,boolean hasFocus) {
            setBorder( null );
            setFont(  normalFont );
            setClosedIcon( folderClosedIcon );
            setOpenIcon( folderOpenIcon );
            if ( value != null && value instanceof TypeNode)
            {
                TypeNode typeNode =(TypeNode)value;
                Icon bigFolderIcon;
                if ( typeNode.getType().equals( User.TYPE))
                {
                    bigFolderIcon = getI18n().getIcon("icon.big_folder_users");
                } 
                else if ( typeNode.getType().equals( Period.TYPE))
                {
                    bigFolderIcon = getI18n().getIcon("icon.big_folder_periods");
                } 
                else if ( typeNode.getType().equals( Reservation.TYPE))
                {
                    if ( typeNode.isFiltered())
                    {
                        bigFolderIcon = getI18n().getIcon("icon.big_folder_events_filtered"); 
                    }
                    else
                    {
                        bigFolderIcon = getI18n().getIcon("icon.big_folder_events");
                    }
                } 
                else if ( typeNode.getType().equals( Conflict.TYPE))
                {
                    bigFolderIcon = getI18n().getIcon("icon.big_folder_conflicts");
                } 
                else 
                {
                    if ( typeNode.isFiltered())
                    {
                        bigFolderIcon = getI18n().getIcon("icon.big_folder_resources_filtered"); 
                    }
                    else
                    {
                        bigFolderIcon = getI18n().getIcon("icon.big_folder_resources");
                    }
               }
               setClosedIcon( bigFolderIcon );
               setOpenIcon( bigFolderIcon );
               setLeafIcon( bigFolderIcon );
               setFont( bigFont );
               value = typeNode.getTitle();
            } 
            else if (value instanceof CategoryNode) 
            {
                Category category = (( CategoryNode) value).getCategory();
                if ( category.getParent() == null) {
                    setClosedIcon( getI18n().getIcon("icon.big_folder_categories") );
                    setOpenIcon( getI18n().getIcon("icon.big_folder_categories") );
                    setFont( bigFont );
                } else {
                    boolean hasChildren = category.getCategories().length > 0;
                    if ( !hasChildren) {
                        setClosedIcon( null );
                        setOpenIcon( null );
                        setLeafIcon( null );
                        setBorder( nonIconBorder );
                    }
                }
            } 
            else 
            {
                Object nodeInfo = getTheUserObject( value );
                if (nodeInfo instanceof Conflict) 
                {
                    Conflict conflict = (Conflict) nodeInfo;
                    String text = getInfoFactory().getToolTip( conflict );
                    value = text ;
                    setBorder ( conflictBorder );
                    setLeafIcon( null );
                } 
                else 
                {
                    setClosedIcon( folderClosedIcon );
                    setOpenIcon( folderOpenIcon );
                    if ( leaf ) 
                    {
                        setLeaf( nodeInfo);
                    }
                }
            }
            Component result = super.getTreeCellRendererComponent(tree, value,
                                                                  sel, expanded,
                                                                  leaf, row,  hasFocus);
            return result;
        }

    }


    private static Object getTheUserObject( Object node ){
        if (node instanceof DefaultMutableTreeNode)
            return ((DefaultMutableTreeNode) node).getUserObject();
        if (node instanceof RecursiveNode)
            return ((RecursiveNode) node).getUserObject();
        return node;
    }

    class RaplaTreeToolTipRenderer implements TreeToolTipRenderer {
        public String getToolTipText(JTree tree,int row) {
            Object node = tree.getPathForRow(row).getLastPathComponent();
            Object value = getTheUserObject( node );
            if ( value instanceof Conflict) {
                return null;
            }
            return getInfoFactory().getToolTip(value);
        }
    }



}