import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
protected void collectTemplates() throws JRException
{
	templates = new ArrayList<JRTemplate>();

	if (reportTemplates != null)
	{
		for (JRFillReportTemplate reportTemplate : reportTemplates)
		{
			JRTemplate template = reportTemplate.evaluate();
			if (template != null)
			{
				templates.add(template);
			}
		}
	}

	Collection<JRTemplate> paramTemplates = (Collection<JRTemplate>) mainDataset.getParameterValue(
			JRParameter.REPORT_TEMPLATES, true);
	if (paramTemplates != null)
	{
		templates.addAll(paramTemplates);
	}
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
protected void collectStyles(JRTemplate template, List<JRStyle> externalStyles, 
		Set<String> loadedLocations, Set<String> templateParentLocations) throws JRException
{
	collectIncludedTemplates(template, externalStyles, 
			loadedLocations, templateParentLocations);

	JRStyle[] templateStyles = template.getStyles();
	if (templateStyles != null)
	{
		for (int i = 0; i < templateStyles.length; i++)
		{
			JRStyle style = templateStyles[i];
			String styleName = style.getName();
			if (styleName == null)
			{
				throw 
					new JRRuntimeException(
						EXCEPTION_MESSAGE_KEY_EXTERNAL_STYLE_NAME_NOT_SET,  
						(Object[])null 
						);
			}

			externalStyles.add(style);
		}
	}
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
/**
 * Constructs a fill context.
 */
public JRFillContext(BaseReportFiller masterFiller)
{
	this.masterFiller = masterFiller;
	this.jasperReportsContext = masterFiller.getJasperReportsContext();
	this.styledTextUtil = JRStyledTextUtil.getInstance(jasperReportsContext);
	
	loadedImageRenderers = new HashMap<Object,Renderable>();
	renderersCache = new RenderersCache(jasperReportsContext);
	loadedSubreports = new HashMap<Object,JasperReport>();
	loadedTemplates = new HashMap<Object,JRTemplate>();
	deduplicableRegistry = new DeduplicableRegistry();
	
	FontUtil.getInstance(jasperReportsContext).resetThreadMissingFontsCache();
	
	legacyElementStretchEnabled = 
		JRPropertiesUtil.getInstance(jasperReportsContext).getBooleanProperty(
			StretchTypeEnum.PROPERTY_LEGACY_ELEMENT_STRETCH_ENABLED
			);
	
	legacyBandEvaluationEnabled = 
		JRPropertiesUtil.getInstance(jasperReportsContext).getBooleanProperty(
			JRCalculator.PROPERTY_LEGACY_BAND_EVALUATION_ENABLED
			);
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
private Map<String, Object> prepareReportParameters(ReportType reportType, OperationResult parentResult) {
    Map<String, Object> params = new HashMap<String, Object>();
    if (reportType.getTemplateStyle() != null) {
        byte[] reportTemplateStyleBase64 = reportType.getTemplateStyle();
        byte[] reportTemplateStyle = Base64.decodeBase64(reportTemplateStyleBase64);
        try {
            LOGGER.trace("Style template string {}", new String(reportTemplateStyle));
            InputStream inputStreamJRTX = new ByteArrayInputStream(reportTemplateStyle);
            JRTemplate templateStyle = JRXmlTemplateLoader.load(inputStreamJRTX);
            params.put(PARAMETER_TEMPLATE_STYLES, templateStyle);
            LOGGER.trace("Style template parameter {}", templateStyle);

        } catch (Exception ex) {
            LOGGER.error("Error create style template parameter {}", ex.getMessage());
            throw new SystemException(ex);
        }

    }

    // for our special datasource
    params.put(PARAMETER_REPORT_OID, reportType.getOid());
    params.put(PARAMETER_OPERATION_RESULT, parentResult);
    params.put(ReportService.PARAMETER_REPORT_SERVICE, reportService);

    return params;
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
@Override
public void componentShowing() {
    super.componentShowing();
    JRTemplate template = ((JRTXEditorSupport)cloneableEditorSupport()).getCurrentModel();
    if (template != null && ((JRTXEditorSupport)cloneableEditorSupport()).isModified())
    {
        // Update the content...
        try {
                String content = JRXmlTemplateWriter.writeTemplate(template,"UTF-8");
                getEditorPane().setText(content);
                getEditorPane().setCaretPosition(0);
                ((JRTXVisualView)((JRTXEditorSupport)cloneableEditorSupport()).descriptions[0]).setNeedModelRefresh(false);
        } catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }
    ((JRTXEditorSupport)cloneableEditorSupport()).setCurrentModel(null);
    
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
/**
 * Returns the XML representation of a template.
 * 
 * @param jasperReportsContext
 * @param template the template
 * @param encoding the XML encoding to use
 * @return the XML representation of the template
 */
public static String writeTemplate(JasperReportsContext jasperReportsContext,
		JRTemplate template, String encoding)
{
	StringWriter stringOut = new StringWriter();
	try
	{
		writeTemplate(jasperReportsContext, template, stringOut, encoding);
	}
	catch (IOException e)
	{
		throw new JRRuntimeException(e);
	}
	return stringOut.toString();
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
/**
 * Creates an XML template writer.
 * 
 * @param jasperReportsContext
 * @param template the template to write
 * @param out the output writer
 * @param encoding the XML encoding to use
 */
public JRXmlTemplateWriter(JasperReportsContext jasperReportsContext, 
		JRTemplate template, Writer out, String encoding)
{
	this.template = template;
	this.encoding = encoding;
	
	String version = JRPropertiesUtil.getInstance(jasperReportsContext).getProperty(JRXmlBaseWriter.PROPERTY_REPORT_VERSION);
	useWriter(new JRXmlWriteHelper(out), version);
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
protected List<JRStyle> collectTemplateStyles() throws JRException
{
	collectTemplates();
	
	List<JRStyle> externalStyles = new ArrayList<JRStyle>();
	HashSet<String> loadedLocations = new HashSet<String>();
	for (JRTemplate template : templates)
	{
		collectStyles(template, externalStyles, loadedLocations);
	}
	return externalStyles;
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
protected void collectIncludedTemplates(JRTemplate template, List<JRStyle> externalStyles, 
		Set<String> loadedLocations, Set<String> templateParentLocations) throws JRException
{
	JRTemplateReference[] includedTemplates = template.getIncludedTemplates();
	if (includedTemplates != null)
	{
		for (int i = 0; i < includedTemplates.length; i++)
		{
			JRTemplateReference reference = includedTemplates[i];
			String location = reference.getLocation();

			if (!templateParentLocations.add(location))
			{
				throw 
					new JRRuntimeException(
						EXCEPTION_MESSAGE_KEY_CIRCULAR_DEPENDENCY_FOUND,  
						new Object[]{location} 
						);
			}
			
			if (loadedLocations.add(location))
			{
				//template not yet loaded
				JRTemplate includedTemplate = JRFillReportTemplate.loadTemplate(
						location, this);
				collectStyles(includedTemplate, externalStyles, 
						loadedLocations, templateParentLocations);
				
			}
		}
	}
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
protected void xml2model(InputStream in) {
	JRTemplate jd = JRXmlTemplateLoader.load(in);
	ANode m = new MRoot(null, new JasperDesign());
	IFile file = ((IFileEditorInput) getEditorInput()).getFile();
	MStylesTemplate ms = new MStylesTemplate(m, file);
	ms.setValue(jd);
	ms.setJasperConfiguration(jrContext);
	StyleTemplateFactory.createTemplate(ms, new HashSet<String>(), true, file, file.getLocation().toFile(),
			(JRSimpleTemplate) jd);
	setModel(m);
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
private static DRStyle[] loadStyles(JRTemplate template) {
	Validate.notNull(template, "template must not be null");
	JRStyle[] jrStyles = template.getStyles();
	DRStyle[] styles = new DRStyle[jrStyles.length];
	for (int i = 0; i < jrStyles.length; i++) {
		JRStyle jrStyle = jrStyles[i];
		styles[i] = convertStyle(jrStyle);
	}
	return styles;
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
protected void loadTemplateStyles(String location, Set<String> loadedLocations, Set<String> parentLocations)
{
	if (!parentLocations.add(location))
	{
		throw 
			new JRRuntimeException(
				EXCEPTION_MESSAGE_KEY_CIRCULAR_DEPENDENCY_FOUND,  
				new Object[]{location} 
				);
	}
	
	if (!loadedLocations.add(location))
	{
		//already loaded
		return;
	}
	
	JRTemplate template;
	try
	{
		template = JRXmlTemplateLoader.getInstance(getJasperReportsContext()).loadTemplate(location);
	}
	catch (Exception e)
	{
		log.warn("Could not load template from location " + location 
				+ "; some styles might remain unresolved.");
		return;
	}
	
	JRTemplateReference[] includedTemplates = template.getIncludedTemplates();
	if (includedTemplates != null)
	{
		for (int i = 0; i < includedTemplates.length; i++)
		{
			JRTemplateReference reference = includedTemplates[i];
			loadTemplateStyles(reference.getLocation(), loadedLocations, parentLocations);
		}
	}
	
	collectStyles(template.getStyles());
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
/**
 * @see #loadTemplate(String)
 */
public static JRTemplate load(String location) throws JRException
{
	return getDefaultInstance().loadTemplate(location);
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
protected static JRTemplate loadTemplate(Object source, JRBaseFiller filler) throws JRException
{
	JRTemplate template;
	if (filler.fillContext.hasLoadedTemplate(source))
	{
		template = filler.fillContext.getLoadedTemplate(source);
	}
	else
	{
		if (log.isDebugEnabled())
		{
			log.debug("Loading styles template from " + source);
		}
		
		if (source instanceof String)
		{
			template = JRXmlTemplateLoader.getInstance(filler.getJasperReportsContext()).loadTemplate((String) source);
		}
		else if (source instanceof File)
		{
			template = JRXmlTemplateLoader.getInstance(filler.getJasperReportsContext()).loadTemplate((File) source);
		}
		else if (source instanceof URL)
		{
			template = JRXmlTemplateLoader.getInstance(filler.getJasperReportsContext()).loadTemplate((URL) source);
		}
		else if (source instanceof InputStream)
		{
			template = JRXmlTemplateLoader.getInstance(filler.getJasperReportsContext()).loadTemplate((InputStream) source);
		}
		else
		{
			throw 
				new JRRuntimeException(
					EXCEPTION_MESSAGE_KEY_UNKNOWN_TEMPLATE_SOURCE,  
					new Object[]{source.getClass().getName()} 
					);
		}
		
		filler.fillContext.registerLoadedTemplate(source, template);
	}
	return template;
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
public List<JRTemplate> getTemplates()
{
	return templates;
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
protected void copyTemplatesParameter(Map<String, Object> parameterValues)
{
	// copy the main report's templates
	List<JRTemplate> templates = filler.getTemplates();
	parameterValues.put(JRParameter.REPORT_TEMPLATES, templates);
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
public void setPreviewStyle(JRStyle style, JRTemplate template)
{
    // Remove the styles...
     STYLE_REPORT.setDefaultStyle(null);
     STYLE_REPORT.getStylesList().clear();
     STYLE_REPORT.getStylesMap().clear();

    if (style == null)
    {
        jLabelStyleName.setText("No style selected");
        jPanelGraphicElements.repaint();
        jPanelTextElements.repaint();
        setElementsStyle(null);
    }
    else
    {
        jLabelStyleName.setText(style.getName());
        try {
            JRStyle[] styles = template.getStyles();
            for (int i=0; i<styles.length; ++i)
            {
                STYLE_REPORT.addStyle(styles[i]);
                if (styles[i].isDefault()) {
                    STYLE_REPORT.setDefaultStyle(style);
                }
            }
            
            // The current style has the precedence...
            if (style.isDefault()) {
                STYLE_REPORT.setDefaultStyle(style);
            }
            setElementsStyle(style);
            jPanelGraphicElements.repaint();
            jPanelTextElements.repaint();
        } catch (JRException ex)
        {

        }

    }
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
/**
 * Writes the XML representation of a template to a file.
 * <p/>
 * Uses {@link #DEFAULT_ENCODING the default encoding}.
 * 
 * @param template the template
 * @param outputFile the output file name
 */
public static void writeTemplateToFile(JRTemplate template, String outputFile)
{
	writeTemplateToFile(template, outputFile, DEFAULT_ENCODING);
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
/**
 * Parses a template XML found at a specified location into a {@link JRTemplate template object}.
 * 
 * @param location the template XML location.
 * 	Can be a URL, a file path or a classloader resource name.
 * @return the template object
 * @throws JRException when the location cannot be resolved or read
 * @see RepositoryUtil#getBytesFromLocation(String)
 */
public JRTemplate loadTemplate(String location) throws JRException
{
	byte[] data = RepositoryUtil.getInstance(jasperReportsContext).getBytesFromLocation(location);
	return load(new ByteArrayInputStream(data));
}
 

import net.sf.jasperreports.engine.JRTemplate; //导入依赖的package包/类
/**
 * Gets a cached template.
 * 
 * @param source the source of the templage
 * @return the cached templage
 * @see #registerLoadedTemplate(Object, JRTemplate)
 */
public JRTemplate getLoadedTemplate(Object source)
{
	return loadedTemplates.get(source); 
}