import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
@Override
protected boolean operation(int i, Map<String, CSSProperty> properties,
		Map<String, Term<?>> values) {

	final Set<Clip> allowedClips = EnumSet.of(Clip.AUTO);

	Clip clip = null;

	if (terms.get(i) instanceof TermIdent
			&& (clip = genericPropertyRaw(Clip.class, allowedClips,
					(TermIdent) terms.get(i))) != null) {
		properties.put(names.get(i), clip);
		return true;
	} else
		return genericTermLength(terms.get(i),
				names.get(i), Clip.rect, false, properties, values);
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
@Override
public void setParent(ElementBox parent)
{
    super.setParent(parent);
    if (getParent() != null)
    {
        //load the relevant style values
        transform = getParent().getStyle().getProperty("text-transform");
        if (transform == null)
            transform = TextTransform.NONE;
        //reset the whitespace processing according to the parent settings
        CSSProperty.WhiteSpace ws = getParent().getWhiteSpace();
        if (ws != ElementBox.WHITESPACE_NORMAL || transform != TextTransform.NONE)
            setWhiteSpace(ws);
    }
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
public <T extends CSSProperty> T getProperty(String name,
		boolean includeInherited) {
	
	Quadruple q = map.get(name);
	if(q==null) return null;
	
	CSSProperty tmp;
	
	if(includeInherited) {
		if(q.curProp!=null) tmp = q.curProp;
		else tmp = q.inhProp;
	}
	else {
		tmp = q.curProp;
	}
	
	// this will cast to inferred type
	// if there is no inferred type, cast to CSSProperty is safe
	// otherwise the possibility having wrong left side of assignment
	// is roughly the same as use wrong dynamic class cast 
	@SuppressWarnings("unchecked")
	T retval = (T) tmp;
	return retval;
	
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
public NodeData push(Declaration d) {
	
	Map<String,CSSProperty> properties = 
		new HashMap<String,CSSProperty>(COMMON_DECLARATION_SIZE);
	Map<String,Term<?>> terms = 
		new HashMap<String, Term<?>>(COMMON_DECLARATION_SIZE);
	
	boolean result = transformer.parseDeclaration(d, properties, terms);
	
	// in case of false do not insert anything
	if(!result) return this;
	
	for(String key: properties.keySet()) {
		Quadruple q = map.get(key);
		if(q==null) q = new Quadruple();
		q.curProp = properties.get(key);
		q.curValue = terms.get(key);
		// remove operator
		if(q.curValue!=null) q.curValue = q.curValue.setOperator(null);
		map.put(key, q);
	}
	return this;

}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
/**
 * Creates INHERIT value of given class
 * 
 * @param i
 *            Ordinal in list of types
 * @return Created CSSProperty with value inherit
 * @throws UnsupportedOperationException
 *             If class does not provide INHERIT or is not implementation of
 *             CSSProperty
 */
private CSSProperty createInherit(int i) {

	try {
		Class<? extends CSSProperty> clazz = types.get(i);
		CSSProperty property = CSSProperty.Translator.createInherit(clazz);
		if (property != null)
			return property;

		throw new IllegalAccessException("No inherit value for: "
				+ clazz.getName());
	} catch (Exception e) {
		throw new UnsupportedOperationException(
				"Unable to create inherit value", e);
	}

}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
/**
 * Uses variator functionality to test selected variant on term
 * 
 * @param variant
 *            Which variant will be tested
 * @param d
 *            The declaration on which variant will be tested
 * @param properties
 *            Properties map where to store property type
 * @param values
 *            Values map where to store property value
 * @return <code>true</code> in case of success, <code>false</code>
 *         otherwise
 */
public boolean tryOneTermVariant(int variant, Declaration d,
		Map<String, CSSProperty> properties, Map<String, Term<?>> values) {

	// only one term is allowed
	if (d.size() != 1)
		return false;

	// try inherit variant
	if (checkInherit(variant, d.get(0), properties))
		return true;

	this.terms = new ArrayList<Term<?>>();
	this.terms.add(d.get(0));

	return variant(variant, new IntegerRef(0), properties, values);
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
@SuppressWarnings("unused")
private boolean processQuotes(Declaration d,
		Map<String, CSSProperty> properties, Map<String, Term<?>> values) {

	if (d.size() == 1
			&& genericTermIdent(Quotes.class, d.get(0), ALLOW_INH,
					"quotes", properties)) {
		return true;
	} else {
		TermList list = tf.createList();
		for (Term<?> term : d.asList()) {
			if (term instanceof TermString)
				list.add(term);
			else
				return false;
		}

		// there are pairs of quotes
		if (!list.isEmpty() && list.size() % 2 == 0) {
			properties.put("quotes", Quotes.list_values);
			values.put("quotes", list);
			return true;
		}
		return false;
	}
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
public <T extends CSSProperty> T getProperty(String name, boolean includeInherited) {

		CSSProperty inh = null, tmp = null;
		
		if(includeInherited) 
			inh = propertiesInh.get(name);

		tmp = propertiesOwn.get(name);
		if(tmp==null) tmp = inh;
		
		// this will cast to inferred type
		// if there is no inferred type, cast to CSSProperty is safe
		// otherwise the possibility having wrong left side of assignment
		// is roughly the same as use wrong dynamic class cast 
		@SuppressWarnings("unchecked")
		T retval = (T) tmp;
		return retval;
	}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
/**
 * Processes an unknown property and stores its value. Unknown properties containing
 * multiple values are ignored (the interpretation is not clear).
 * 
 * @param d the declaration.
 * @param properties the properties.
 * @param values the values.
 * 
 * @return <code>true</code>, if the property has been pared successfully
 */
private boolean processAdditionalCSSGenericProperty(Declaration d, Map<String, CSSProperty> properties, Map<String, Term<?>> values)
{
	if (d.size() == 1)
	{
     Term<?> term = d.get(0);
	
     if (term instanceof TermIdent)
         return genericProperty(GenericCSSPropertyProxy.class, (TermIdent) term, true, properties, d.getProperty());
     else
         return genericTerm(TermLength.class, term, d.getProperty(), null, false, properties, values)
             || genericTerm(TermPercent.class, term, d.getProperty(), null, false, properties, values)
             || genericTerm(TermInteger.class, term, d.getProperty(), null, false, properties, values)
             || genericTermColor(term, d.getProperty(), null, properties, values);
	}
	else
	{
		log.warn("Ignoring unsupported property " + d.getProperty() + " with multiple values");
		return false;
	}
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
@Override
public boolean vary(Map<String, CSSProperty> properties,
		Map<String, Term<?>> values) {

	// special check for user interface values
	// such as "caption", "icon" or "menu"
	// this will break inheritance division into distint categories,
	// so it must be reconstructed later
	if (terms.size() == 1 && terms.get(0) instanceof TermIdent) {

		if (checkInherit(ALL_VARIANTS, terms.get(0), properties))
			return true;

		return genericTermIdent(Font.class, terms.get(0), AVOID_INH,
				"font", properties);
	}
	// follow basic control flow
	return super.vary(properties, values);
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
@SuppressWarnings("unused")
private boolean processOutline(Declaration d,
		Map<String, CSSProperty> properties, Map<String, Term<?>> values) {
	Variator outline = new OutlineVariator();
	outline.assignTermsFromDeclaration(d);
	outline.assignDefaults(properties, values);
	return outline.vary(properties, values);
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
protected void writeBorderSVG(ElementBox eb, int x1, int y1, int x2, int y2, String side, int width, int right, int down, PrintWriter out) throws IOException
{
    TermColor tclr = eb.getStyle().getValue(TermColor.class, "border-"+side+"-color");
    CSSProperty.BorderStyle bst = eb.getStyle().getProperty("border-"+side+"-style");
    if (tclr != null && bst != CSSProperty.BorderStyle.HIDDEN)
    {
        Color clr = tclr.getValue();
        if (clr == null) clr = Color.BLACK;

        String stroke = "";
        if (bst == CSSProperty.BorderStyle.SOLID)
        {
            stroke = "stroke-width:" + width;
        }
        else if (bst == CSSProperty.BorderStyle.DOTTED)
        {
            stroke = "stroke-width:" + width + ";stroke-dasharray:" + width + "," + width;
        }
        else if (bst == CSSProperty.BorderStyle.DASHED)
        {
            stroke = "stroke-width:" + width + ";stroke-dasharray:" + (3*width) + "," + width;
        }
        else if (bst == CSSProperty.BorderStyle.DOUBLE)
        {
            //double is not supported yet, we'll use single
            stroke = "stroke-width:" + width;
        }
        else //default or unsupported - draw a solid line
        {
            stroke = "stroke-width:" + width;
        }
        
        String coords = "M " + (x1+right) + "," + (y1+down) + " L " + (x2+right) + "," + (y2+down);
        String style = "fill:none;stroke:" + colorString(clr) + ";" + stroke;
        out.println("<path style=\"" + style + "\" d=\"" + coords + "\" />");  
    }
    
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
@Override
protected void computeWidthsInFlow(TermLengthOrPercent width, boolean auto, boolean exact, int contw, boolean update)
{
    //The same as for absolutely positioned boxes (shrink-to-fit or explicitely set)
    CSSDecoder dec = new CSSDecoder(ctx);
    
    if (width == null) auto = true; //no value behaves as "auto"

    boolean mleftauto = style.getProperty("margin-left") == CSSProperty.Margin.AUTO;
    TermLengthOrPercent mleft = getLengthValue("margin-left");
    boolean mrightauto = style.getProperty("margin-right") == CSSProperty.Margin.AUTO;
    TermLengthOrPercent mright = getLengthValue("margin-right");
    preferredWidth = -1;
    
    if (!widthComputed) update = false;
    
    if (auto)
    {
        if (exact) wset = false;
        if (!update)
            content.width = dec.getLength(width, auto, 0, 0, contw);
        preferredWidth = -1; //we don't prefer anything (auto width)
    }
    else
    {
        if (exact) 
        {
            wset = true;
            wrelative = width.isPercentage();
        }
        content.width = dec.getLength(width, auto, 0, 0, contw);
    }

    //auto margins are treated as zero
    margin.left = dec.getLength(mleft, mleftauto, 0, 0, contw);
    margin.right = dec.getLength(mright, mrightauto, 0, 0, contw);
    
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
@SuppressWarnings("unused")
private boolean processMaxHeight(Declaration d,
		Map<String, CSSProperty> properties, Map<String, Term<?>> values) {
	return genericOneIdentOrLengthOrPercent(MaxHeight.class,
			MaxHeight.length, MaxHeight.percentage, true, d, properties,
			values);
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
/**
 * Sets the whitespace processing for this box. The text content is then treated accordingly. The text start and text end
 * indices are reset to their initial values.
 */
public void setWhiteSpace(CSSProperty.WhiteSpace value)
{
    splitws = (value == ElementBox.WHITESPACE_NORMAL || value == ElementBox.WHITESPACE_PRE_WRAP || value== ElementBox.WHITESPACE_PRE_LINE);
    collapsews = (value == ElementBox.WHITESPACE_NORMAL || value == ElementBox.WHITESPACE_NOWRAP || value == ElementBox.WHITESPACE_PRE_LINE);
    linews = (value == ElementBox.WHITESPACE_NORMAL || value == ElementBox.WHITESPACE_NOWRAP);
    //When this is the original box, apply the whitespace. For the copied boxes, the whitespace has been already applied (they contain
    //a copy of the original, already processed content). 
    if (!splitted)
        applyWhiteSpace();
    //recompute widths (possibly different wrapping)
    computeLineLengths();
    minwidth = computeMinimalWidth();
    maxwidth = computeMaximalWidth();
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
/** 
 * Draw the text content of this box (no subboxes)
 * @param g the graphics context to draw on
 */
protected void drawContent(Graphics2D g)
{
    //top left corner
    int x = absbounds.x;
    int y = absbounds.y;

    //Draw the string
    if (textEnd > textStart)
    {
        String t = text.substring(textStart, textEnd);
        Shape oldclip = g.getClip();
        g.setClip(clipblock.getClippedContentBounds());
        ctx.updateGraphics(g);
        
        if (!ctx.getTextDecoration().isEmpty()) 
        {
            AttributedString as = new AttributedString(t);
            as.addAttribute(TextAttribute.FONT, ctx.getFont());
            if (ctx.getTextDecoration().contains(CSSProperty.TextDecoration.UNDERLINE))
                as.addAttribute(TextAttribute.UNDERLINE, TextAttribute.UNDERLINE_ON);
            if (ctx.getTextDecoration().contains(CSSProperty.TextDecoration.LINE_THROUGH))
                as.addAttribute(TextAttribute.STRIKETHROUGH, TextAttribute.STRIKETHROUGH_ON);
            g.drawString(as.getIterator(), x, y + getBaselineOffset());
        } 
        else
            g.drawString(t, x, y + getBaselineOffset());
        
        g.setClip(oldclip);
    }
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
/**
 * Creates variator which contains <code>variants</code> variants to be
 * tested
 * 
 * @param variants
 */
public Variator(int variants) {
	this.variants = variants;
	this.variantPassed = new boolean[variants];
	for (int i = 0; i < variants; i++)
		variantPassed[i] = false;
	this.names = new ArrayList<String>(variants);
	this.types = new ArrayList<Class<? extends CSSProperty>>(variants);
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
/**
 * Assigns the default values to all the properties.
 * @param properties
 * @param values
 */
public void assignDefaults(Map<String, CSSProperty> properties, Map<String, Term<?>> values) {
    SupportedCSS css = CSSFactory.getSupportedCSS();
    for (String name : names) {
        CSSProperty dp = css.getDefaultProperty(name);
        if (dp != null)
            properties.put(name, dp);
        Term<?> dv = css.getDefaultValue(name);
        if (dv != null)
            values.put(name, dv);
    }
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
protected <T extends CSSProperty> boolean genericOneIdentOrInteger(
		Class<T> type, T integerIdentification, boolean sanify,
		Declaration d, Map<String, CSSProperty> properties,
		Map<String, Term<?>> values) {

	if (d.size() != 1)
		return false;

	return genericTermIdent(type, d.get(0), ALLOW_INH, d.getProperty(),
			properties)
			|| genericTerm(TermInteger.class, d.get(0), d.getProperty(),
					integerIdentification, sanify, properties, values);
}
 

import cz.vutbr.web.css.CSSProperty; //导入依赖的package包/类
protected <T extends CSSProperty> boolean genericOneIdentOrIntegerOrNumber(
        Class<T> type, T integerIdentification, T numberIdentification, boolean sanify,
        Declaration d, Map<String, CSSProperty> properties,
        Map<String, Term<?>> values) {

    if (d.size() != 1)
        return false;

    return genericTermIdent(type, d.get(0), ALLOW_INH, d.getProperty(), properties)
            || genericTerm(TermInteger.class, d.get(0), d.getProperty(),
                    integerIdentification, sanify, properties, values)
            || genericTerm(TermNumber.class, d.get(0), d.getProperty(),
                    numberIdentification, sanify, properties, values);
}