KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > prefuse > render > DefaultRendererFactory


1 package prefuse.render;
2
3 import prefuse.data.expression.Predicate;
4 import prefuse.data.expression.parser.ExpressionParser;
5 import prefuse.util.PredicateChain;
6 import prefuse.visual.EdgeItem;
7 import prefuse.visual.VisualItem;
8
9
10 /**
11  * <p>Default factory implementation from which to retrieve VisualItem
12  * renderers.</p>
13  *
14  * <p>
15  * This class supports the use of a default renderer for EdgeItems (the default
16  * edge renderer) and another for all other non-edge VisualItems (the default
17  * item renderer). In addition, any number of additional Renderer mapping rules
18  * can be added, by specifying a Predicate to apply and a Renderer to return
19  * for matching items. Predicate/Renderer mappings are checked in the order in
20  * which they were added to the factory.
21  * </p>
22  *
23  * <p>If left unspecified, a {@link ShapeRenderer} is used as the default
24  * item renderer and an {@link EdgeRenderer} instance is used as the default
25  * edge renderer.</p>
26  *
27  * <p>For example, the following code snippet creates a new
28  * DefaultRendererFactory, changes the default edge renderer to be an
29  * EdgeRenderer using curved edges, and adds a new rule which maps items in
30  * the group "data" to a text renderer that pulls its text from a field named
31  * "label".</p>
32  * <pre>
33  * DefaultRendererFactory rf = new DefaultRendererFactory();
34  * rf.setDefaultEdgeRenderer(new EdgeRenderer(Constants.EDGE_TYPE_CURVE);
35  * rf.addRenderer("INGROUP('data')", new LabelRenderer("label");
36  * </pre>
37  *
38  * @author <a HREF="http://jheer.org">jeffrey heer</a>
39  */
40 public class DefaultRendererFactory implements RendererFactory {
41
42     private PredicateChain m_chain = new PredicateChain();
43     private Renderer m_itemRenderer;
44     private Renderer m_edgeRenderer;
45     
46     /**
47      * Default Constructor. A ShapeRenderer instance will be used for the
48      * default item renderer and an EdgeRenderer instance will be used for the
49      * default edge renderer.
50      * @see ShapeRenderer
51      * @see EdgeRenderer
52      */
53     public DefaultRendererFactory() {
54        this(new ShapeRenderer());
55     }
56     
57     /**
58      * Constructor. Creates a new DefaultRendererFactory with the specified
59      * default item renderer. An EdgeRenderer instance will be used for the
60      * default edge renderer.
61      * @param itemRenderer the default item renderer. This is the default for
62      * rendering all items except EdgeItem instances.
63      * @see EdgeRenderer
64      */
65     public DefaultRendererFactory(Renderer itemRenderer) {
66         this(itemRenderer, new EdgeRenderer());
67     }
68     
69     /**
70      * Constructor. Creates a new DefaultRendererFactory with the specified
71      * default item and edge renderers.
72      * @param itemRenderer the default item renderer. This is the default for
73      * rendering all items except EdgeItem instances.
74      * @param edgeRenderer the default edge renderer. This is the default for
75      * rendering EdgeItem instances.
76      */
77     public DefaultRendererFactory(Renderer itemRenderer, Renderer edgeRenderer)
78     {
79         m_itemRenderer = itemRenderer;
80         m_edgeRenderer = edgeRenderer;
81     }
82
83     // ------------------------------------------------------------------------
84
85     /**
86      * Sets the default renderer. This renderer will be returned by
87      * {@link #getRenderer(VisualItem)} whenever there are no matching
88      * predicates and the input item <em>is not</em> an EdgeItem. To set the
89      * default renderer for EdgeItems, see
90      * {@link #setDefaultEdgeRenderer(Renderer)}.
91      * @param r the Renderer to use as the default
92      * @see #setDefaultEdgeRenderer(Renderer)
93      */
94     public void setDefaultRenderer(Renderer r) {
95         m_itemRenderer = r;
96     }
97     
98     /**
99      * Gets the default renderer. This renderer will be returned by
100      * {@link #getRenderer(VisualItem)} whenever there are no matching
101      * predicates and the input item <em>is not</em> an EdgeItem.
102      * @return the default Renderer for non-edge VisualItems
103      */
104     public Renderer getDefaultRenderer() {
105         return m_itemRenderer;
106     }
107     
108     /**
109      * Sets the default edge renderer. This renderer will be returned by
110      * {@link #getRenderer(VisualItem)} whenever there are no matching
111      * predicates and the input item <em>is</em> an EdgeItem. To set the
112      * default renderer for non-EdgeItems, see
113      * {@link #setDefaultRenderer(Renderer)}.
114      * @param r the Renderer to use as the default for EdgeItems
115      * @see #setDefaultRenderer(Renderer)
116      */
117     public void setDefaultEdgeRenderer(Renderer r) {
118         m_edgeRenderer = r;
119     }
120     
121     /**
122      * Gets the default edge renderer. This renderer will be returned by
123      * {@link #getRenderer(VisualItem)} whenever there are no matching
124      * predicates and the input item <em>is</em> an EdgeItem.
125      * @return the default Renderer for EdgeItems
126      */
127     public Renderer getDefaultEdgeRenderer() {
128         return m_edgeRenderer;
129     }
130     
131     /**
132      * Adds a new mapping to this RendererFactory. If an input item to
133      * {@link #getRenderer(VisualItem)} matches the predicate, then the
134      * corresponding Renderer will be returned. Predicates are evaluated in the
135      * order in which they are added, so if an item matches multiple
136      * predicates, the Renderer for the earliest match will be returned.
137      * @param p a Predicate for testing a VisualItem
138      * @param r the Renderer to return if an item matches the Predicate
139      */
140     public void add(Predicate p, Renderer r) {
141         m_chain.add(p, r);
142     }
143     
144     /**
145      * Adds a new mapping to this RendererFactory. If an input item to
146      * {@link #getRenderer(VisualItem)} matches the predicate, then the
147      * corresponding Renderer will be returned. Predicates are evaluated in the
148      * order in which they are added, so if an item matches multiple
149      * predicates, the Renderer for the earliest match will be returned.
150      * @param predicate a String in the prefuse expression language. This
151      * String will be parsed to create a corresponding Predicate instance.
152      * @param r the Renderer to return if an item matches the Predicate
153      */
154     public void add(String JavaDoc predicate, Renderer r) {
155         Predicate p = (Predicate)ExpressionParser.parse(predicate);
156         add(p, r);
157     }
158     
159     /**
160      * Return a Renderer instance for the input VisualItem. The VisualItem
161      * is matched against the registered Predicates, and if a match is found
162      * the corresponding Renderer is returned. Predicate matches are evaluated
163      * in the order in which Predicate/Renderer mappings were added to this
164      * RendererFactory. If no matches are found, either the default renderer
165      * (for all VisualItems except EdgeItems) or the default edge renderer (for
166      * EdgeItems) is returned.
167      */
168     public Renderer getRenderer(VisualItem item) {
169         Renderer r = (Renderer)m_chain.get(item);
170         if ( r != null )
171             return r;
172         else if ( item instanceof EdgeItem )
173             return m_edgeRenderer;
174         else
175             return m_itemRenderer;
176     }
177     
178 } // end of class DefaultRendererFactory
179
Popular Tags