1 /*
2  * JasperReports - Free Java Reporting Library.
3  * Copyright (C) 2001 - 2019 TIBCO Software Inc. All rights reserved.
4  * http://www.jaspersoft.com
5  *
6  * Unless you have purchased a commercial license agreement from Jaspersoft,
7  * the following license terms apply:
8  *
9  * This program is part of JasperReports.
10  *
11  * JasperReports is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License as published by
13  * the Free Software Foundation, either version 3 of the License, or
14  * (at your option) any later version.
15  *
16  * JasperReports is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * along with JasperReports. If not, see <http://www.gnu.org/licenses/>.
23  */
24 package net.sf.jasperreports.engine.fill;
25
26 import java.util.ArrayList;
27 import java.util.HashMap;
28 import java.util.HashSet;
29 import java.util.Iterator;
30 import java.util.LinkedList;
31 import java.util.List;
32 import java.util.Map;
33 import java.util.Set;
34
35 import org.apache.commons.collections4.map.LinkedMap;
36 import org.apache.commons.logging.Log;
37 import org.apache.commons.logging.LogFactory;
38
39 import net.sf.jasperreports.charts.JRAreaPlot;
40 import net.sf.jasperreports.charts.JRBar3DPlot;
41 import net.sf.jasperreports.charts.JRBarPlot;
42 import net.sf.jasperreports.charts.JRBubblePlot;
43 import net.sf.jasperreports.charts.JRCandlestickPlot;
44 import net.sf.jasperreports.charts.JRCategoryDataset;
45 import net.sf.jasperreports.charts.JRCategorySeries;
46 import net.sf.jasperreports.charts.JRChartAxis;
47 import net.sf.jasperreports.charts.JRGanttDataset;
48 import net.sf.jasperreports.charts.JRGanttSeries;
49 import net.sf.jasperreports.charts.JRHighLowDataset;
50 import net.sf.jasperreports.charts.JRHighLowPlot;
51 import net.sf.jasperreports.charts.JRLinePlot;
52 import net.sf.jasperreports.charts.JRMeterPlot;
53 import net.sf.jasperreports.charts.JRMultiAxisPlot;
54 import net.sf.jasperreports.charts.JRPie3DPlot;
55 import net.sf.jasperreports.charts.JRPieDataset;
56 import net.sf.jasperreports.charts.JRPiePlot;
57 import net.sf.jasperreports.charts.JRPieSeries;
58 import net.sf.jasperreports.charts.JRScatterPlot;
59 import net.sf.jasperreports.charts.JRThermometerPlot;
60 import net.sf.jasperreports.charts.JRTimePeriodDataset;
61 import net.sf.jasperreports.charts.JRTimePeriodSeries;
62 import net.sf.jasperreports.charts.JRTimeSeries;
63 import net.sf.jasperreports.charts.JRTimeSeriesDataset;
64 import net.sf.jasperreports.charts.JRTimeSeriesPlot;
65 import net.sf.jasperreports.charts.JRValueDataset;
66 import net.sf.jasperreports.charts.JRXyDataset;
67 import net.sf.jasperreports.charts.JRXySeries;
68 import net.sf.jasperreports.charts.JRXyzDataset;
69 import net.sf.jasperreports.charts.JRXyzSeries;
70 import net.sf.jasperreports.charts.fill.JRFillAreaPlot;
71 import net.sf.jasperreports.charts.fill.JRFillBar3DPlot;
72 import net.sf.jasperreports.charts.fill.JRFillBarPlot;
73 import net.sf.jasperreports.charts.fill.JRFillBubblePlot;
74 import net.sf.jasperreports.charts.fill.JRFillCandlestickPlot;
75 import net.sf.jasperreports.charts.fill.JRFillCategoryDataset;
76 import net.sf.jasperreports.charts.fill.JRFillCategorySeries;
77 import net.sf.jasperreports.charts.fill.JRFillChartAxis;
78 import net.sf.jasperreports.charts.fill.JRFillGanttDataset;
79 import net.sf.jasperreports.charts.fill.JRFillGanttSeries;
80 import net.sf.jasperreports.charts.fill.JRFillHighLowDataset;
81 import net.sf.jasperreports.charts.fill.JRFillHighLowPlot;
82 import net.sf.jasperreports.charts.fill.JRFillLinePlot;
83 import net.sf.jasperreports.charts.fill.JRFillMeterPlot;
84 import net.sf.jasperreports.charts.fill.JRFillMultiAxisPlot;
85 import net.sf.jasperreports.charts.fill.JRFillPie3DPlot;
86 import net.sf.jasperreports.charts.fill.JRFillPieDataset;
87 import net.sf.jasperreports.charts.fill.JRFillPiePlot;
88 import net.sf.jasperreports.charts.fill.JRFillPieSeries;
89 import net.sf.jasperreports.charts.fill.JRFillScatterPlot;
90 import net.sf.jasperreports.charts.fill.JRFillThermometerPlot;
91 import net.sf.jasperreports.charts.fill.JRFillTimePeriodDataset;
92 import net.sf.jasperreports.charts.fill.JRFillTimePeriodSeries;
93 import net.sf.jasperreports.charts.fill.JRFillTimeSeries;
94 import net.sf.jasperreports.charts.fill.JRFillTimeSeriesDataset;
95 import net.sf.jasperreports.charts.fill.JRFillTimeSeriesPlot;
96 import net.sf.jasperreports.charts.fill.JRFillValueDataset;
97 import net.sf.jasperreports.charts.fill.JRFillXyDataset;
98 import net.sf.jasperreports.charts.fill.JRFillXySeries;
99 import net.sf.jasperreports.charts.fill.JRFillXyzDataset;
100 import net.sf.jasperreports.charts.fill.JRFillXyzSeries;
101 import net.sf.jasperreports.crosstabs.JRCrosstab;
102 import net.sf.jasperreports.crosstabs.JRCrosstabDataset;
103 import net.sf.jasperreports.crosstabs.JRCrosstabParameter;
104 import net.sf.jasperreports.crosstabs.fill.JRFillCrosstabParameter;
105 import net.sf.jasperreports.engine.ExpressionReturnValue;
106 import net.sf.jasperreports.engine.JRAbstractObjectFactory;
107 import net.sf.jasperreports.engine.JRBand;
108 import net.sf.jasperreports.engine.JRBreak;
109 import net.sf.jasperreports.engine.JRChart;
110 import net.sf.jasperreports.engine.JRComponentElement;
111 import net.sf.jasperreports.engine.JRConditionalStyle;
112 import net.sf.jasperreports.engine.JRDataset;
113 import net.sf.jasperreports.engine.JRDatasetRun;
114 import net.sf.jasperreports.engine.JRDefaultStyleProvider;
115 import net.sf.jasperreports.engine.JRElementGroup;
116 import net.sf.jasperreports.engine.JREllipse;
117 import net.sf.jasperreports.engine.JRExpression;
118 import net.sf.jasperreports.engine.JRField;
119 import net.sf.jasperreports.engine.JRFrame;
120 import net.sf.jasperreports.engine.JRGenericElement;
121 import net.sf.jasperreports.engine.JRGroup;
122 import net.sf.jasperreports.engine.JRImage;
123 import net.sf.jasperreports.engine.JRLine;
124 import net.sf.jasperreports.engine.JRParameter;
125 import net.sf.jasperreports.engine.JRRectangle;
126 import net.sf.jasperreports.engine.JRReportTemplate;
127 import net.sf.jasperreports.engine.JRRuntimeException;
128 import net.sf.jasperreports.engine.JRSection;
129 import net.sf.jasperreports.engine.JRStaticText;
130 import net.sf.jasperreports.engine.JRStyle;
131 import net.sf.jasperreports.engine.JRStyleContainer;
132 import net.sf.jasperreports.engine.JRStyleSetter;
133 import net.sf.jasperreports.engine.JRSubreport;
134 import net.sf.jasperreports.engine.JRSubreportReturnValue;
135 import net.sf.jasperreports.engine.JRTextField;
136 import net.sf.jasperreports.engine.JRVariable;
137 import net.sf.jasperreports.engine.VariableReturnValue;
138 import net.sf.jasperreports.engine.analytics.dataset.FillMultiAxisData;
139 import net.sf.jasperreports.engine.analytics.dataset.MultiAxisData;
140 import net.sf.jasperreports.engine.base.JRBaseConditionalStyle;
141 import net.sf.jasperreports.engine.base.JRBaseStyle;
142
143
144 /**
145  * A factory used to instantiate fill objects based on compiled report objects.
146  * 
147  * @author Teodor Danciu (teodord@users.sourceforge.net)
148  */
149 public class JRFillObjectFactory extends JRAbstractObjectFactory
150 {
151
152     private static final Log log = LogFactory.getLog(JRFillObjectFactory.class);
153
154     public static final String EXCEPTION_MESSAGE_KEY_UNRESOLVED_STYLE = "fill.object.factory.unresolved.style";
155     public static final String EXCEPTION_MESSAGE_KEY_STYLE_NOT_FOUND = "fill.object.factory.style.not.found";
156     
157     /**
158      *
159      */
160     protected JRBaseFiller filler;
161     protected BaseReportFiller reportFiller;
162     private JRFillExpressionEvaluator evaluator;
163
164     private JRFillObjectFactory parentFiller;
165     
166 //    private JRFont defaultFont;
167
168     private List<JRFillElementDataset> elementDatasets = new ArrayList<JRFillElementDataset>();
169     private Map<String,List<JRFillElementDataset>> elementDatasetMap = new HashMap<String,List<JRFillElementDataset>>();
170     
171     private LinkedList<List<JRFillDatasetRun>> trackedDatasetRunsStack = new LinkedList<List<JRFillDatasetRun>>();
172     
173     private Map<String,List<JRStyleSetter>> delayedStyleSettersByName = new HashMap<String,List<JRStyleSetter>>();
174     
175     protected static class StylesList
176     {
177         private final List<JRStyle> styles = new ArrayList<JRStyle>();
178         private final Map<String,Integer> stylesIdx = new HashMap<String,Integer>();
179         
180         public boolean containsStyle(String name)
181         {
182             return stylesIdx.containsKey(name);
183         }
184         
185         public JRStyle getStyle(String name)
186         {
187             Integer idx = stylesIdx.get(name);
188             return idx == null ? null : styles.get(idx);
189         }
190         
191         public void addStyle(JRStyle style)
192         {
193             styles.add(style);
194             stylesIdx.put(style.getName(), styles.size() - 1);
195         }
196         
197         public void renamed(String oldName, String newName)
198         {
199             Integer idx = stylesIdx.remove(oldName);
200             stylesIdx.put(newName, idx);
201         }
202     }
203     
204     private Set<JRStyle> originalStyleList;
205     private StylesList stylesMap = new StylesList();
206
207
208     /**
209      *
210      */
211     protected JRFillObjectFactory(JRBaseFiller filler)
212     {
213         this(filler, filler.calculator);
214     }
215
216
217     /**
218      *
219      */
220     public JRFillObjectFactory(JRBaseFiller filler, JRFillExpressionEvaluator expressionEvaluator)
221     {
222         this.filler = filler;
223         this.reportFiller = filler;
224         this.evaluator = expressionEvaluator;
225     }
226
227     
228     public JRFillObjectFactory(JRFillObjectFactory parent, JRFillExpressionEvaluator expressionEvaluator)
229     {
230         this.parentFiller = parent;
231         this.filler = parent.filler;
232         this.reportFiller = parent.reportFiller;
233         this.evaluator = expressionEvaluator;
234     }
235
236     
237     public JRFillObjectFactory(BaseReportFiller reportFiller)
238     {
239         this.reportFiller = reportFiller;
240         this.evaluator = reportFiller.calculator;
241     }
242
243
244     /**
245      * Returns the expression evaluator which is to be used by objects
246      * created by this factory.
247      * 
248      * @return the expression evaluator associated with this factory
249      */
250     public JRFillExpressionEvaluator getExpressionEvaluator()
251     {
252         return evaluator;
253     }
254
255     /**
256      *
257      */
258     protected JRFillChartDataset[] getDatasets()
259     {
260         return elementDatasets.toArray(new JRFillChartDataset[elementDatasets.size()]);
261     }
262
263
264     protected JRFillElementDataset[] getElementDatasets(JRDataset dataset)
265     {
266         JRFillElementDataset[] elementDatasetsArray;
267         List<JRFillElementDataset> elementDatasetsList;
268         if (dataset.isMainDataset())
269         {
270             elementDatasetsList = elementDatasets;
271         }
272         else
273         {
274             elementDatasetsList = elementDatasetMap.get(dataset.getName());
275         }
276
277         if (elementDatasetsList == null || elementDatasetsList.size() == 0)
278         {
279             elementDatasetsArray = new JRFillElementDataset[0];
280         }
281         else
282         {
283             elementDatasetsArray = new JRFillElementDataset[elementDatasetsList.size()];
284             elementDatasetsList.toArray(elementDatasetsArray);
285         }
286
287         return elementDatasetsArray;
288     }
289
290
291     protected void registerDelayedStyleSetter(JRStyleSetter delayedSetter, String styleName)
292     {
293         if (parentFiller == null)
294         {
295             List<JRStyleSetter> setters = delayedStyleSettersByName.get(styleName);
296             if (setters == null)
297             {
298                 setters = new ArrayList<JRStyleSetter>();
299                 delayedStyleSettersByName.put(styleName, setters);
300             }
301             
302             setters.add(delayedSetter);
303         }
304         else
305         {
306             parentFiller.registerDelayedStyleSetter(delayedSetter, styleName);
307         }
308     }
309
310     public void registerDelayedStyleSetter(JRStyleSetter delayedSetter, JRStyleContainer styleContainer)
311     {
312         JRStyle style = styleContainer.getStyle();
313         String nameReference = styleContainer.getStyleNameReference();
314         if (style != null)
315         {
316             registerDelayedStyleSetter(delayedSetter, style.getName());
317         }
318         else if (nameReference != null)
319         {
320             registerDelayedStyleSetter(delayedSetter, nameReference);
321         }
322     }
323     
324     @Override
325     public JRBaseStyle getStyle(JRStyle style)
326     {
327         JRBaseStyle fillStyle = null;
328
329         if (style != null)
330         {
331             fillStyle = (JRBaseStyle) get(style);
332             if (fillStyle == null)
333             {
334                 fillStyle = new JRBaseStyle(style, this);
335                 
336                 // deduplicate to previously created identical instances
337                 fillStyle = filler.fillContext.deduplicate(fillStyle);
338                 
339                 put(style, fillStyle);
340                 
341                 if (originalStyleList != null && originalStyleList.contains(style))
342                 {
343                     renameExistingStyle(style.getName());
344                     stylesMap.addStyle(style);
345                 }                
346             }
347         }
348
349         return fillStyle;
350     }
351
352     protected void renameExistingStyle(String name)
353     {
354         JRStyle originalStyle = stylesMap.getStyle(name);
355         if (originalStyle != null)
356         {
357             //found a previous external style with the same name
358             //renaming the previous style
359             JRBaseStyle style = (JRBaseStyle) get(originalStyle);
360             
361             String newName;
362             int suf = 1;
363             do
364             {
365                 newName = name + suf;
366                 ++suf;
367             }
368             while(stylesMap.containsStyle(newName));
369             
370             style.rename(newName);
371             stylesMap.renamed(name, newName);
372         }
373     }
374
375
376     @Override
377     public void setStyle(JRStyleSetter setter, JRStyleContainer styleContainer)
378     {
379         JRStyle style = styleContainer.getStyle();
380         String nameReference = styleContainer.getStyleNameReference();
381         if (style != null)
382         {
383             JRStyle newStyle = getStyle(style);
384             setter.setStyle(newStyle);
385         }
386         else if (nameReference != null)
387         {
388             JRStyle originalStyle = stylesMap.getStyle(nameReference);
389             if (originalStyle == null)
390             {
391                 throw 
392                     new JRRuntimeException(
393                         EXCEPTION_MESSAGE_KEY_UNRESOLVED_STYLE,  
394                         new Object[]{nameReference} 
395                         );
396             }
397             
398             JRStyle externalStyle = (JRStyle) get(originalStyle);
399             setter.setStyle(externalStyle);
400         }
401     }
402
403
404     /**
405      *
406      */
407     protected JRFillParameter getParameter(JRParameter parameter)
408     {
409         JRFillParameter fillParameter = null;
410
411         if (parameter != null)
412         {
413             fillParameter = (JRFillParameter)get(parameter);
414             if (fillParameter == null)
415             {
416                 fillParameter = new JRFillParameter(parameter, this);
417             }
418         }
419
420         return fillParameter;
421     }
422
423
424     /**
425      *
426      */
427     protected JRFillField getField(JRField field)
428     {
429         JRFillField fillField = null;
430
431         if (field != null)
432         {
433             fillField = (JRFillField)get(field);
434             if (fillField == null)
435             {
436                 fillField = new JRFillField(field, this);
437             }
438         }
439
440         return fillField;
441     }
442
443
444     /**
445      *
446      */
447     public JRFillVariable getVariable(JRVariable variable)
448     {
449         JRFillVariable fillVariable = null;
450
451         if (variable != null)
452         {
453             fillVariable = (JRFillVariable)get(variable);
454             if (fillVariable == null)
455             {
456                 fillVariable = new JRFillVariable(variable, this);
457             }
458         }
459
460         return fillVariable;
461     }
462
463
464     /**
465      *
466      */
467     public JRFillGroup getGroup(JRGroup group)
468     {
469         JRFillGroup fillGroup = null;
470
471         if (group != null)
472         {
473             fillGroup = (JRFillGroup)get(group);
474             if (fillGroup == null)
475             {
476                 fillGroup = new JRFillGroup(group, this);
477             }
478         }
479
480         return fillGroup;
481     }
482
483
484     /**
485      *
486      */
487     protected JRFillSection getSection(JRSection section)
488     {
489         JRFillSection fillSection = null;
490
491         if (section == null)
492         {
493             fillSection = filler.missingFillSection;
494         }
495         else
496         {
497             fillSection = (JRFillSection)get(section);
498             if (fillSection == null)
499             {
500                 fillSection = new JRFillSection(filler, section, this);
501             }
502         }
503
504         return fillSection;
505     }
506
507
508     /**
509      *
510      */
511     protected JRFillBand getBand(JRBand band)
512     {
513         JRFillBand fillBand = null;
514
515         if (band == null)
516         {
517             fillBand = filler.missingFillBand;
518         }
519         else
520         {
521             fillBand = (JRFillBand)get(band);
522             if (fillBand == null)
523             {
524                 fillBand = new JRFillBand(filler, band, this);
525             }
526         }
527
528         return fillBand;
529     }
530
531
532     @Override
533     public void visitElementGroup(JRElementGroup elementGroup)
534     {
535         JRFillElementGroup fillElementGroup = null;
536
537         if (elementGroup != null)
538         {
539             fillElementGroup = (JRFillElementGroup)get(elementGroup);
540             if (fillElementGroup == null)
541             {
542                 fillElementGroup = new JRFillElementGroup(elementGroup, this);
543             }
544         }
545
546         setVisitResult(fillElementGroup);
547     }
548
549
550     @Override
551     public void visitBreak(JRBreak breakElement)
552     {
553         JRFillBreak fillBreak = null;
554
555         if (breakElement != null)
556         {
557             fillBreak = (JRFillBreak)get(breakElement);
558             if (fillBreak == null)
559             {
560                 fillBreak = new JRFillBreak(filler, breakElement, this);
561             }
562         }
563
564         setVisitResult(fillBreak);
565     }
566
567
568     @Override
569     public void visitLine(JRLine line)
570     {
571         JRFillLine fillLine = null;
572
573         if (line != null)
574         {
575             fillLine = (JRFillLine)get(line);
576             if (fillLine == null)
577             {
578                 fillLine = new JRFillLine(filler, line, this);
579             }
580         }
581
582         setVisitResult(fillLine);
583     }
584
585
586     @Override
587     public void visitRectangle(JRRectangle rectangle)
588     {
589         JRFillRectangle fillRectangle = null;
590
591         if (rectangle != null)
592         {
593             fillRectangle = (JRFillRectangle)get(rectangle);
594             if (fillRectangle == null)
595             {
596                 fillRectangle = new JRFillRectangle(filler, rectangle, this);
597             }
598         }
599
600         setVisitResult(fillRectangle);
601     }
602
603
604     @Override
605     public void visitEllipse(JREllipse ellipse)
606     {
607         JRFillEllipse fillEllipse = null;
608
609         if (ellipse != null)
610         {
611             fillEllipse = (JRFillEllipse)get(ellipse);
612             if (fillEllipse == null)
613             {
614                 fillEllipse = new JRFillEllipse(filler, ellipse, this);
615             }
616         }
617
618         setVisitResult(fillEllipse);
619     }
620
621
622     @Override
623     public void visitImage(JRImage image)
624     {
625         JRFillImage fillImage = null;
626
627         if (image != null)
628         {
629             fillImage = (JRFillImage)get(image);
630             if (fillImage == null)
631             {
632                 fillImage = new JRFillImage(filler, image, this);
633             }
634         }
635
636         setVisitResult(fillImage);
637     }
638
639
640     @Override
641     public void visitStaticText(JRStaticText staticText)
642     {
643         JRFillStaticText fillStaticText = null;
644
645         if (staticText != null)
646         {
647             fillStaticText = (JRFillStaticText)get(staticText);
648             if (fillStaticText == null)
649             {
650                 fillStaticText = new JRFillStaticText(filler, staticText, this);
651             }
652         }
653
654         setVisitResult(fillStaticText);
655     }
656
657
658     @Override
659     public void visitTextField(JRTextField textField)
660     {
661         JRFillTextField fillTextField = null;
662
663         if (textField != null)
664         {
665             fillTextField = (JRFillTextField)get(textField);
666             if (fillTextField == null)
667             {
668                 fillTextField = new JRFillTextField(filler, textField, this);
669             }
670         }
671
672         setVisitResult(fillTextField);
673     }
674
675
676     @Override
677     public void visitSubreport(JRSubreport subreport)
678     {
679         JRFillSubreport fillSubreport = null;
680
681         if (subreport != null)
682         {
683             fillSubreport = (JRFillSubreport)get(subreport);
684             if (fillSubreport == null)
685             {
686                 fillSubreport = new JRFillSubreport(filler, subreport, this);
687             }
688         }
689
690         setVisitResult(fillSubreport);
691     }
692
693
694     @Override
695     public void visitChart(JRChart chart)
696     {
697         JRFillChart fillChart = null;
698
699         if (chart != null)
700         {
701             fillChart = (JRFillChart)get(chart);
702             if (fillChart == null)
703             {
704                 fillChart = new JRFillChart(filler, chart, this);
705             }
706         }
707
708         setVisitResult(fillChart);
709     }
710
711
712     @Override
713     public JRPieDataset getPieDataset(JRPieDataset pieDataset)
714     {
715         JRFillPieDataset fillPieDataset = null;
716
717         if (pieDataset != null)
718         {
719             fillPieDataset = (JRFillPieDataset)get(pieDataset);
720             if (fillPieDataset == null)
721             {
722                 fillPieDataset = new JRFillPieDataset(pieDataset, this);
723                 registerElementDataset(fillPieDataset);
724             }
725         }
726
727         return fillPieDataset;
728     }
729
730
731     @Override
732     public JRPiePlot getPiePlot(JRPiePlot piePlot)
733     {
734         JRFillPiePlot fillPiePlot = null;
735
736         if (piePlot != null)
737         {
738             fillPiePlot = (JRFillPiePlot)get(piePlot);
739             if (fillPiePlot == null)
740             {
741                 fillPiePlot = new JRFillPiePlot(piePlot, this);
742             }
743         }
744
745         return fillPiePlot;
746     }
747
748
749     @Override
750     public JRPie3DPlot getPie3DPlot(JRPie3DPlot pie3DPlot)
751     {
752         JRFillPie3DPlot fillPie3DPlot = null;
753
754         if (pie3DPlot != null)
755         {
756             fillPie3DPlot = (JRFillPie3DPlot)get(pie3DPlot);
757             if (fillPie3DPlot == null)
758             {
759                 fillPie3DPlot = new JRFillPie3DPlot(pie3DPlot, this);
760             }
761         }
762
763         return fillPie3DPlot;
764     }
765
766
767     @Override
768     public JRCategoryDataset getCategoryDataset(JRCategoryDataset categoryDataset)
769     {
770         JRFillCategoryDataset fillCategoryDataset = null;
771
772         if (categoryDataset != null)
773         {
774             fillCategoryDataset = (JRFillCategoryDataset)get(categoryDataset);
775             if (fillCategoryDataset == null)
776             {
777                 fillCategoryDataset = new JRFillCategoryDataset(categoryDataset, this);
778                 registerElementDataset(fillCategoryDataset);
779             }
780         }
781
782         return fillCategoryDataset;
783     }
784
785     @Override
786     public JRXyzDataset getXyzDataset( JRXyzDataset xyzDataset ){
787         JRFillXyzDataset fillXyzDataset = null;
788         if( xyzDataset != null ){
789             fillXyzDataset = (JRFillXyzDataset)get( xyzDataset );
790             if( fillXyzDataset == null ){
791                 fillXyzDataset = new JRFillXyzDataset( xyzDataset, this );
792                 registerElementDataset(fillXyzDataset);
793             }
794         }
795
796         return fillXyzDataset;
797
798     }
799
800
801     /**
802      *
803      */
804     public JRXyDataset getXyDataset(JRXyDataset xyDataset)
805     {
806         JRFillXyDataset fillXyDataset = null;
807
808         if (xyDataset != null)
809         {
810             fillXyDataset = (JRFillXyDataset)get(xyDataset);
811             if (fillXyDataset == null)
812             {
813                 fillXyDataset = new JRFillXyDataset(xyDataset, this);
814                 registerElementDataset(fillXyDataset);
815             }
816         }
817
818         return fillXyDataset;
819     }
820
821
822     @Override
823     public JRTimeSeriesDataset getTimeSeriesDataset( JRTimeSeriesDataset timeSeriesDataset ){
824         JRFillTimeSeriesDataset fillTimeSeriesDataset = null;
825
826         if( timeSeriesDataset != null ){
827
828             fillTimeSeriesDataset = (JRFillTimeSeriesDataset)get( timeSeriesDataset );
829
830             if( fillTimeSeriesDataset == null ){
831                 fillTimeSeriesDataset = new JRFillTimeSeriesDataset( timeSeriesDataset, this );
832                 registerElementDataset(fillTimeSeriesDataset);
833             }
834         }
835
836         return fillTimeSeriesDataset;
837     }
838
839     @Override
840     public JRTimePeriodDataset getTimePeriodDataset( JRTimePeriodDataset timePeriodDataset ){
841         JRFillTimePeriodDataset fillTimePeriodDataset = null;
842         if( timePeriodDataset != null ){
843             fillTimePeriodDataset = (JRFillTimePeriodDataset)get( timePeriodDataset );
844             if( fillTimePeriodDataset == null ){
845                 fillTimePeriodDataset = new JRFillTimePeriodDataset( timePeriodDataset, this );
846                 registerElementDataset(fillTimePeriodDataset);
847             }
848         }
849         return fillTimePeriodDataset;
850     }
851     
852     /**
853      * 
854      */
855     public JRGanttDataset getGanttDataset(JRGanttDataset ganttDataset)
856     {
857         JRFillGanttDataset fillGanttDataset = null;
858         
859         if (ganttDataset != null)
860         {
861             fillGanttDataset = (JRFillGanttDataset)get(ganttDataset);
862             if (fillGanttDataset == null)
863             {
864                 fillGanttDataset = new JRFillGanttDataset(ganttDataset, this);
865                 registerElementDataset(fillGanttDataset);
866             }
867         }
868         
869         return fillGanttDataset;
870     }
871     
872     @Override
873     public JRPieSeries getPieSeries(JRPieSeries pieSeries)
874     {
875         JRFillPieSeries fillPieSeries = null;
876
877         if (pieSeries != null)
878         {
879             fillPieSeries = (JRFillPieSeries)get(pieSeries);
880             if (fillPieSeries == null)
881             {
882                 fillPieSeries = new JRFillPieSeries(pieSeries, this);
883             }
884         }
885
886         return fillPieSeries;
887     }
888
889
890     @Override
891     public JRCategorySeries getCategorySeries(JRCategorySeries categorySeries)
892     {
893         JRFillCategorySeries fillCategorySeries = null;
894
895         if (categorySeries != null)
896         {
897             fillCategorySeries = (JRFillCategorySeries)get(categorySeries);
898             if (fillCategorySeries == null)
899             {
900                 fillCategorySeries = new JRFillCategorySeries(categorySeries, this);
901             }
902         }
903
904         return fillCategorySeries;
905     }
906
907
908     @Override
909     public JRXyzSeries getXyzSeries( JRXyzSeries xyzSeries ){
910         JRFillXyzSeries fillXyzSeries = null;
911
912         if( xyzSeries != null ){
913             fillXyzSeries = (JRFillXyzSeries)get( xyzSeries );
914
915             if( fillXyzSeries == null ){
916                 fillXyzSeries = new JRFillXyzSeries( xyzSeries, this );
917             }
918         }
919
920         return fillXyzSeries;
921     }
922
923
924     /**
925      *
926      */
927     public JRXySeries getXySeries(JRXySeries xySeries)
928     {
929         JRFillXySeries fillXySeries = null;
930
931         if (xySeries != null)
932         {
933             fillXySeries = (JRFillXySeries)get(xySeries);
934             if (fillXySeries == null)
935             {
936                 fillXySeries = new JRFillXySeries(xySeries, this);
937             }
938         }
939
940         return fillXySeries;
941     }
942     
943     
944     /**
945      * 
946      */
947     public JRGanttSeries getGanttSeries(JRGanttSeries ganttSeries)
948     {
949         JRFillGanttSeries fillGanttSeries = null;
950         
951         if (ganttSeries != null)
952         {
953             fillGanttSeries = (JRFillGanttSeries)get(ganttSeries);
954             if (fillGanttSeries == null)
955             {
956                 fillGanttSeries = new JRFillGanttSeries(ganttSeries, this);
957             }
958         }
959         
960         return fillGanttSeries;
961     }
962     
963     
964     @Override
965     public JRBarPlot getBarPlot(JRBarPlot barPlot)
966     {
967         JRFillBarPlot fillBarPlot = null;
968
969         if (barPlot != null)
970         {
971             fillBarPlot = (JRFillBarPlot)get(barPlot);
972             if (fillBarPlot == null)
973             {
974                 fillBarPlot = new JRFillBarPlot(barPlot, this);
975             }
976         }
977
978         return fillBarPlot;
979     }
980
981
982     @Override
983     public JRTimeSeries getTimeSeries(JRTimeSeries timeSeries)
984     {
985         JRFillTimeSeries fillTimeSeries = null;
986
987         if (timeSeries != null)
988         {
989             fillTimeSeries = (JRFillTimeSeries)get(timeSeries);
990             if (fillTimeSeries == null)
991             {
992                 fillTimeSeries = new JRFillTimeSeries(timeSeries, this);
993             }
994         }
995
996         return fillTimeSeries;
997     }
998
999     @Override
1000     public JRTimePeriodSeries getTimePeriodSeries( JRTimePeriodSeries timePeriodSeries ){
1001         JRFillTimePeriodSeries fillTimePeriodSeries = null;
1002         if( timePeriodSeries != null ){
1003             fillTimePeriodSeries = (JRFillTimePeriodSeries)get( timePeriodSeries );
1004             if( fillTimePeriodSeries == null ){
1005                 fillTimePeriodSeries = new JRFillTimePeriodSeries( timePeriodSeries, this );
1006             }
1007         }
1008
1009         return fillTimePeriodSeries;
1010     }
1011
1012
1013     @Override
1014     public JRBar3DPlot getBar3DPlot(JRBar3DPlot barPlot) {
1015         JRFillBar3DPlot fillBarPlot = null;
1016
1017         if (barPlot != null){
1018             fillBarPlot = (JRFillBar3DPlot)get(barPlot);
1019             if (fillBarPlot == null){
1020                 fillBarPlot = new JRFillBar3DPlot(barPlot, this);
1021             }
1022         }
1023
1024         return fillBarPlot;
1025     }
1026
1027
1028     @Override
1029     public JRLinePlot getLinePlot(JRLinePlot linePlot) {
1030         JRFillLinePlot fillLinePlot = null;
1031
1032         if (linePlot != null){
1033             fillLinePlot = (JRFillLinePlot)get(linePlot);
1034             if (fillLinePlot == null){
1035                 fillLinePlot = new JRFillLinePlot(linePlot, this);
1036             }
1037         }
1038
1039         return fillLinePlot;
1040     }
1041
1042
1043     /**
1044      *
1045      */
1046     public JRScatterPlot getScatterPlot(JRScatterPlot scatterPlot) {
1047         JRFillScatterPlot fillScatterPlot = null;
1048
1049         if (scatterPlot != null){
1050             fillScatterPlot = (JRFillScatterPlot)get(scatterPlot);
1051             if (fillScatterPlot == null){
1052                 fillScatterPlot = new JRFillScatterPlot(scatterPlot, this);
1053             }
1054         }
1055
1056         return fillScatterPlot;
1057     }
1058
1059
1060     @Override
1061     public JRAreaPlot getAreaPlot(JRAreaPlot areaPlot) {
1062         JRFillAreaPlot fillAreaPlot = null;
1063
1064         if (areaPlot != null)
1065         {
1066             fillAreaPlot = (JRFillAreaPlot)get(areaPlot);
1067             if (fillAreaPlot == null)
1068             {
1069                 fillAreaPlot = new JRFillAreaPlot(areaPlot, this);
1070             }
1071         }
1072
1073         return fillAreaPlot;
1074     }
1075
1076
1077     /* (non-Javadoc)
1078      * @see net.sf.jasperreports.engine.JRAbstractObjectFactory#getBubblePlot(net.sf.jasperreports.charts.JRBubblePlot)
1079      */
1080     @Override
1081     public JRBubblePlot getBubblePlot(JRBubblePlot bubblePlot) {
1082         JRFillBubblePlot fillBubblePlot = null;
1083
1084         if (bubblePlot != null)
1085         {
1086             fillBubblePlot = (JRFillBubblePlot)get(bubblePlot);
1087             if (fillBubblePlot == null)
1088             {
1089                 fillBubblePlot = new JRFillBubblePlot(bubblePlot, this);
1090             }
1091         }
1092
1093         return fillBubblePlot;
1094     }
1095
1096
1097     /**
1098      *
1099      */
1100     public JRHighLowDataset getHighLowDataset(JRHighLowDataset highLowDataset)
1101     {
1102         JRFillHighLowDataset fillHighLowDataset = null;
1103
1104         if (highLowDataset != null)
1105         {
1106             fillHighLowDataset = (JRFillHighLowDataset)get(highLowDataset);
1107             if (fillHighLowDataset == null)
1108             {
1109                 fillHighLowDataset = new JRFillHighLowDataset(highLowDataset, this);
1110                 registerElementDataset(fillHighLowDataset);
1111             }
1112         }
1113
1114         return fillHighLowDataset;
1115     }
1116
1117
1118     /**
1119      *
1120      */
1121     public JRHighLowPlot getHighLowPlot(JRHighLowPlot highLowPlot) {
1122         JRFillHighLowPlot fillHighLowPlot = null;
1123
1124         if (highLowPlot != null){
1125             fillHighLowPlot = (JRFillHighLowPlot)get(highLowPlot);
1126             if (fillHighLowPlot == null){
1127                 fillHighLowPlot = new JRFillHighLowPlot(highLowPlot, this);
1128             }
1129         }
1130
1131         return fillHighLowPlot;
1132     }
1133
1134
1135     @Override
1136     public JRCandlestickPlot getCandlestickPlot(JRCandlestickPlot candlestickPlot)
1137     {
1138         JRFillCandlestickPlot fillCandlestickPlot = null;
1139
1140         if (candlestickPlot != null){
1141             fillCandlestickPlot = (JRFillCandlestickPlot)get(candlestickPlot);
1142             if (fillCandlestickPlot == null){
1143                 fillCandlestickPlot = new JRFillCandlestickPlot(candlestickPlot, this);
1144             }
1145         }
1146
1147         return fillCandlestickPlot;
1148     }
1149
1150
1151
1152     public JRTimeSeriesPlot getTimeSeriesPlot( JRTimeSeriesPlot plot ){
1153         JRFillTimeSeriesPlot fillPlot = null;
1154         if( plot != null ){
1155             fillPlot = (JRFillTimeSeriesPlot)get( plot );
1156             if( fillPlot == null ){
1157                 fillPlot = new JRFillTimeSeriesPlot( plot, this );
1158             }
1159         }
1160
1161         return fillPlot;
1162
1163     }
1164
1165     /**
1166      *
1167      */
1168     public JRValueDataset getValueDataset(JRValueDataset valueDataset)
1169     {
1170         JRFillValueDataset fillValueDataset = null;
1171
1172         if (valueDataset != null)
1173         {
1174             fillValueDataset = (JRFillValueDataset)get(valueDataset);
1175             if (fillValueDataset == null)
1176             {
1177                 fillValueDataset = new JRFillValueDataset(valueDataset, this);
1178                 registerElementDataset(fillValueDataset);
1179             }
1180         }
1181
1182         return fillValueDataset;
1183     }
1184
1185     /**
1186      *
1187      */
1188     public JRMeterPlot getMeterPlot(JRMeterPlot meterPlot)
1189     {
1190         JRFillMeterPlot fillMeterPlot = null;
1191
1192         if (meterPlot != null)
1193         {
1194             fillMeterPlot = (JRFillMeterPlot)get(meterPlot);
1195             if (fillMeterPlot == null)
1196             {
1197                 fillMeterPlot = new JRFillMeterPlot(meterPlot, this);
1198             }
1199         }
1200
1201         return fillMeterPlot;
1202     }
1203
1204     /**
1205      *
1206      */
1207     public JRThermometerPlot getThermometerPlot(JRThermometerPlot thermometerPlot)
1208     {
1209         JRFillThermometerPlot fillThermometerPlot = null;
1210
1211         if (thermometerPlot != null)
1212         {
1213             fillThermometerPlot = (JRFillThermometerPlot)get(thermometerPlot);
1214             if (fillThermometerPlot == null)
1215             {
1216                 fillThermometerPlot = new JRFillThermometerPlot(thermometerPlot, this);
1217             }
1218         }
1219
1220         return fillThermometerPlot;
1221     }
1222
1223
1224     /**
1225      *
1226      */
1227     public JRMultiAxisPlot getMultiAxisPlot(JRMultiAxisPlot multiAxisPlot)
1228     {
1229         JRFillMultiAxisPlot fillMultiAxisPlot = null;
1230
1231         if (multiAxisPlot != null)
1232         {
1233             fillMultiAxisPlot = (JRFillMultiAxisPlot)get(multiAxisPlot);
1234             if (fillMultiAxisPlot == null)
1235             {
1236                 fillMultiAxisPlot = new JRFillMultiAxisPlot(multiAxisPlot, this);
1237             }
1238         }
1239
1240         return fillMultiAxisPlot;
1241     }
1242
1243
1244     protected JRFillVariableReturnValue getSubreportReturnValue(JRSubreportReturnValue returnValue)
1245     {
1246         JRFillVariableReturnValue fillReturnValue = null;
1247
1248         if (returnValue != null)
1249         {
1250             fillReturnValue = (JRFillVariableReturnValue) get(returnValue);
1251             if (fillReturnValue == null)
1252             {
1253                 fillReturnValue = new JRFillVariableReturnValue(returnValue, this, reportFiller);
1254             }
1255         }
1256
1257         return fillReturnValue;
1258     }
1259
1260
1261     protected JRFillVariableReturnValue getReturnValue(VariableReturnValue returnValue)
1262     {
1263         JRFillVariableReturnValue fillReturnValue = null;
1264
1265         if (returnValue != null)
1266         {
1267             fillReturnValue = (JRFillVariableReturnValue) get(returnValue);
1268             if (fillReturnValue == null)
1269             {
1270                 fillReturnValue = new JRFillVariableReturnValue(returnValue, this, filler);
1271             }
1272         }
1273
1274         return fillReturnValue;
1275     }
1276
1277
1278     protected JRFillExpressionReturnValue getReturnValue(ExpressionReturnValue returnValue)
1279     {
1280         JRFillExpressionReturnValue fillReturnValue = null;
1281
1282         if (returnValue != null)
1283         {
1284             fillReturnValue = (JRFillExpressionReturnValue) get(returnValue);
1285             if (fillReturnValue == null)
1286             {
1287                 fillReturnValue = new JRFillExpressionReturnValue(returnValue, this, filler);//FIXMERETURN passing the right filler? 
1288                 //why two possible fillers here after all? if single filler, could remove getSubreportReturnValue() above
1289             }
1290         }
1291
1292         return fillReturnValue;
1293     }
1294
1295
1296     @Override
1297     public void visitCrosstab(JRCrosstab crosstabElement)
1298     {
1299         JRFillCrosstab fillCrosstab = null;
1300
1301         if (crosstabElement != null)
1302         {
1303             fillCrosstab = (JRFillCrosstab) get(crosstabElement);
1304             if (fillCrosstab == null)
1305             {
1306                 fillCrosstab = new JRFillCrosstab(filler, crosstabElement, this);
1307             }
1308         }
1309
1310         setVisitResult(fillCrosstab);
1311     }
1312
1313
1314     public JRFillCrosstab.JRFillCrosstabDataset getCrosstabDataset(JRCrosstabDataset dataset, JRFillCrosstab fillCrosstab)
1315     {
1316         JRFillCrosstab.JRFillCrosstabDataset fillDataset = null;
1317
1318         if (dataset != null)
1319         {
1320             fillDataset = (JRFillCrosstab.JRFillCrosstabDataset)get(dataset);
1321             if (fillDataset == null)
1322             {
1323                 fillDataset = fillCrosstab.new JRFillCrosstabDataset(dataset, this);
1324                 registerElementDataset(fillDataset);
1325             }
1326         }
1327
1328         return fillDataset;
1329     }
1330
1331
1332     public JRFillDataset getDataset(JRDataset dataset)
1333     {
1334         JRFillDataset fillDataset = null;
1335
1336         if (dataset != null)
1337         {
1338             fillDataset = (JRFillDataset) get(dataset);
1339             if (fillDataset == null)
1340             {
1341                 fillDataset = new JRFillDataset(reportFiller, dataset, this);
1342             }
1343         }
1344
1345         return fillDataset;
1346     }
1347
1348
1349     /**
1350      * Register an element dataset with the report filler.
1351      * 
1352      * <p>
1353      * Registration of element datasets is required in order for the filler
1354      * to increment the datasets when iterating through the datasource.
1355      * 
1356      * @param elementDataset the dataset to register
1357      */
1358     public void registerElementDataset(JRFillElementDataset elementDataset)
1359     {
1360         List<JRFillElementDataset> elementDatasetsList;
1361         JRDatasetRun datasetRun = elementDataset.getDatasetRun();
1362         if (datasetRun == null)
1363         {
1364             elementDatasetsList = elementDatasets;
1365         }
1366         else
1367         {
1368             String datasetName = datasetRun.getDatasetName();
1369             elementDatasetsList = getElementDatasetsList(datasetName);
1370             
1371             registerDatasetRun((JRFillDatasetRun) datasetRun);
1372         }
1373         elementDatasetsList.add(elementDataset);
1374     }
1375     
1376     protected List<JRFillElementDataset> getElementDatasetsList(String datasetName)
1377     {
1378         if (parentFiller != null)
1379         {
1380             return parentFiller.getElementDatasetsList(datasetName);
1381         }
1382         
1383         List<JRFillElementDataset> elementDatasetsList = elementDatasetMap.get(datasetName);
1384         if (elementDatasetsList == null)
1385         {
1386             elementDatasetsList = new ArrayList<JRFillElementDataset>();
1387             elementDatasetMap.put(datasetName, elementDatasetsList);
1388         }
1389         return elementDatasetsList;
1390     }
1391
1392     public void trackDatasetRuns()
1393     {
1394         if (log.isDebugEnabled())
1395         {
1396             log.debug("tracking dataset runs");
1397         }
1398
1399         ArrayList<JRFillDatasetRun> trackedDatasets = new ArrayList<JRFillDatasetRun>(2);
1400         trackedDatasetRunsStack.push(trackedDatasets);
1401     }
1402     
1403     public void registerDatasetRun(JRFillDatasetRun datasetRun)
1404     {
1405         if (!trackedDatasetRunsStack.isEmpty())
1406         {
1407             if (log.isDebugEnabled())
1408             {
1409                 log.debug("added tracked dataset run " + datasetRun);
1410             }
1411             
1412             trackedDatasetRunsStack.getFirst().add(datasetRun);
1413         }
1414     }
1415     
1416     public List<JRFillDatasetRun> getTrackedDatasetRuns()
1417     {
1418         if (log.isDebugEnabled())
1419         {
1420             log.debug("poping tracked dataset runs");
1421         }
1422
1423         return trackedDatasetRunsStack.pop();
1424     }
1425
1426     public JRFillDatasetRun getDatasetRun(JRDatasetRun datasetRun)
1427     {
1428         JRFillDatasetRun fillDatasetRun = null;
1429
1430         if (datasetRun != null)
1431         {
1432             fillDatasetRun = (JRFillDatasetRun) get(datasetRun);
1433             if (fillDatasetRun == null)
1434             {
1435                 fillDatasetRun = new JRFillDatasetRun(datasetRun, this);
1436             }
1437         }
1438
1439         return fillDatasetRun;
1440     }
1441
1442
1443     public JRFillCrosstabParameter getCrosstabParameter(JRCrosstabParameter parameter)
1444     {
1445         JRFillCrosstabParameter fillParameter = null;
1446
1447         if (parameter != null)
1448         {
1449             fillParameter = (JRFillCrosstabParameter) get(parameter);
1450             if (fillParameter == null)
1451             {
1452                 fillParameter = new JRFillCrosstabParameter(parameter, this);
1453             }
1454         }
1455
1456         return fillParameter;
1457     }
1458
1459
1460     @Override
1461     public void visitFrame(JRFrame frame)
1462     {
1463         Object fillFrame = null;
1464         // This is the only place where an object gets replaced in the factory map by something else,
1465         // and we can no longer make a precise cast when getting it.
1466         // The JRFillFrame object is replaced in the map by a JRFillFrameElements object.
1467         //JRFillFrame fillFrame = null;
1468
1469         if (frame != null)
1470         {
1471             fillFrame = get(frame);
1472             //fillFrame = (JRFillFrame) get(frame);
1473             if (fillFrame == null)
1474             {
1475                 fillFrame = new JRFillFrame(filler, frame, this);
1476             }
1477         }
1478
1479         setVisitResult(fillFrame);
1480     }
1481
1482     public BaseReportFiller getReportFiller()
1483     {
1484         return reportFiller;
1485     }
1486
1487     /**
1488      * Returns the current report filler.
1489      * 
1490      * @return the current report filler
1491      */
1492     public JRBaseFiller getFiller()
1493     {
1494         return filler;
1495     }
1496
1497
1498     @Override
1499     public JRConditionalStyle getConditionalStyle(JRConditionalStyle conditionalStyle, JRStyle style)
1500     {
1501         JRBaseConditionalStyle baseConditionalStyle = null;
1502         if (conditionalStyle != null)
1503         {
1504             baseConditionalStyle = (JRBaseConditionalStyle) get(conditionalStyle);
1505             if (baseConditionalStyle == null) {
1506                 baseConditionalStyle = new JRBaseConditionalStyle(conditionalStyle, style, this);
1507                 put(conditionalStyle, baseConditionalStyle);
1508             }
1509         }
1510         return baseConditionalStyle;
1511     }
1512
1513
1514     @Override
1515     public JRExpression getExpression(JRExpression expression, boolean assignNotUsedId)
1516     {
1517         return expression;
1518     }
1519
1520
1521     public JRChartAxis getChartAxis(JRChartAxis axis)
1522     {
1523         JRFillChartAxis fillAxis = null;
1524         if (axis != null)
1525         {
1526             fillAxis = (JRFillChartAxis) get(axis);
1527             if (fillAxis == null)
1528             {
1529                 fillAxis = new JRFillChartAxis(axis, this);
1530             }
1531         }
1532         return fillAxis;
1533     }
1534
1535
1536     public JRFillReportTemplate getReportTemplate(JRReportTemplate template)
1537     {
1538         JRFillReportTemplate fillTemplate = null;
1539         if (template != null)
1540         {
1541             fillTemplate = (JRFillReportTemplate) get(template);
1542             if (fillTemplate == null)
1543             {
1544                 fillTemplate = new JRFillReportTemplate(template, filler, this);
1545             }
1546         }
1547         return fillTemplate;
1548     }
1549     
1550     public List<JRStyle> setStyles(List<JRStyle> styles)
1551     {
1552         originalStyleList = new HashSet<JRStyle>(styles);
1553         
1554         //filtering requested styles
1555         Set<JRStyle> requestedStyles = collectRequestedStyles(styles);
1556         
1557         //collect used styles
1558         Map<JRStyle,Object> usedStylesMap = new LinkedMap<JRStyle,Object>();
1559         Map<String,JRStyle> allStylesMap = new HashMap<String,JRStyle>();
1560         for (Iterator<JRStyle> it = styles.iterator(); it.hasNext();)
1561         {
1562             JRStyle style = it.next();
1563             if (requestedStyles.contains(style))
1564             {
1565                 collectUsedStyles(style, usedStylesMap, allStylesMap);
1566             }
1567             allStylesMap.put(style.getName(), style);
1568         }
1569         
1570         List<JRStyle> includedStyles = new ArrayList<JRStyle>();
1571         for (Iterator<JRStyle> it = usedStylesMap.keySet().iterator(); it.hasNext();)
1572         {
1573             JRStyle style = it.next();
1574             JRStyle newStyle = getStyle(style);
1575             
1576             includedStyles.add(newStyle);
1577             if (requestedStyles.contains(style))
1578             {
1579                 useDelayedStyle(newStyle);
1580             }            
1581         }
1582         
1583         checkUnresolvedReferences();
1584         
1585         return includedStyles;
1586     }
1587
1588     protected Set<JRStyle> collectRequestedStyles(List<JRStyle> externalStyles)
1589     {
1590         Map<String,JRStyle> requestedStylesMap = new HashMap<String,JRStyle>();
1591         for (Iterator<JRStyle> it = externalStyles.iterator(); it.hasNext();)
1592         {
1593             JRStyle style = it.next();
1594             String name = style.getName();
1595             if (delayedStyleSettersByName.containsKey(name))
1596             {
1597                 requestedStylesMap.put(name, style);
1598             }
1599         }
1600         
1601         return new HashSet<JRStyle>(requestedStylesMap.values());
1602     }
1603
1604     protected void collectUsedStyles(JRStyle style, Map<JRStyle,Object> usedStylesMap, Map<String,JRStyle> allStylesMap)
1605     {
1606         if (!usedStylesMap.containsKey(style) && originalStyleList.contains(style))
1607         {
1608             JRStyle parent = style.getStyle();
1609             if (parent == null)
1610             {
1611                 String parentName = style.getStyleNameReference();
1612                 if (parentName != null)
1613                 {
1614                     parent = allStylesMap.get(parentName);
1615                     if (parent == null)
1616                     {
1617                         throw 
1618                             new JRRuntimeException(
1619                                 EXCEPTION_MESSAGE_KEY_STYLE_NOT_FOUND,  
1620                                 new Object[]{parentName} 
1621                                 );
1622                     }
1623                 }
1624             }
1625             
1626             if (parent != null)
1627             {
1628                 collectUsedStyles(parent, usedStylesMap, allStylesMap);
1629             }
1630             
1631             usedStylesMap.put(style, null);
1632         }
1633     }
1634     
1635     protected void useDelayedStyle(JRStyle style)
1636     {
1637         List<JRStyleSetter> delayedSetters = delayedStyleSettersByName.remove(style.getName());
1638         if (delayedSetters != null)
1639         {
1640             for (Iterator<JRStyleSetter> it = delayedSetters.iterator(); it.hasNext();)
1641             {
1642                 JRStyleSetter setter = it.next();
1643                 setter.setStyle(style);
1644             }
1645         }
1646     }
1647
1648     protected void checkUnresolvedReferences()
1649     {
1650         if (!delayedStyleSettersByName.isEmpty())
1651         {
1652             StringBuilder errorMsg = new StringBuilder();
1653             for (Iterator<String> it = delayedStyleSettersByName.keySet().iterator(); it.hasNext();)
1654             {
1655                 String name = it.next();
1656                 errorMsg.append(name);
1657                 errorMsg.append(", ");
1658             }
1659             
1660             throw 
1661                 new JRRuntimeException(
1662                     EXCEPTION_MESSAGE_KEY_UNRESOLVED_STYLE,  
1663                     new Object[]{errorMsg.substring(0, errorMsg.length() - 2)} 
1664                     );
1665         }
1666     }
1667
1668     @Override
1669     public JRDefaultStyleProvider getDefaultStyleProvider()
1670     {
1671         return filler.getJasperPrint().getDefaultStyleProvider();
1672     }
1673
1674
1675     @Override
1676     public void visitComponentElement(JRComponentElement componentElement)
1677     {
1678         JRFillComponentElement fill = null;
1679
1680         if (componentElement != null)
1681         {
1682             fill = (JRFillComponentElement) get(componentElement);
1683             if (fill == null)
1684             {
1685                 fill = new JRFillComponentElement(filler, componentElement, this);
1686             }
1687         }
1688
1689         setVisitResult(fill);
1690     }
1691
1692
1693     @Override
1694     public void visitGenericElement(JRGenericElement element)
1695     {
1696         JRFillGenericElement fill = null;
1697         if (element != null)
1698         {
1699             fill = (JRFillGenericElement) get(element);
1700             if (fill == null)
1701             {
1702                 fill = new JRFillGenericElement(filler, element, this);
1703             }
1704         }
1705         setVisitResult(fill);
1706     }
1707
1708     public FillMultiAxisData getBidimensionalData(MultiAxisData data)
1709     {
1710         FillMultiAxisData fillData = null;
1711         if (data != null)
1712         {
1713             fillData = (FillMultiAxisData) get(data);
1714             if (fillData == null)
1715             {
1716                 fillData = new FillMultiAxisData(data, this);
1717             }
1718         }
1719         return fillData;
1720     }
1721
1722 }
1723