| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* $Id$ */ |
| |
| package org.apache.fop.fo.properties; |
| |
| import org.apache.fop.datatypes.CompoundDatatype; |
| import org.apache.fop.fo.Constants; |
| import org.apache.fop.fo.FObj; |
| import org.apache.fop.fo.PropertyList; |
| import org.apache.fop.fo.expr.PropertyException; |
| |
| /** |
| * This class extends Property.Maker with support for sub-properties. |
| */ |
| public class CompoundPropertyMaker extends PropertyMaker { |
| /** |
| * The list of subproperty makers supported by this compound maker. |
| */ |
| private PropertyMaker[] subproperties |
| = new PropertyMaker[Constants.COMPOUND_COUNT]; |
| |
| /** |
| * The first subproperty maker which has a setByShorthand of true. |
| */ |
| private PropertyMaker shorthandMaker; |
| |
| /** |
| * Construct an instance of a CompoundPropertyMaker for the given property. |
| * @param propId The Constant ID of the property to be made. |
| */ |
| public CompoundPropertyMaker(int propId) { |
| super(propId); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public void useGeneric(PropertyMaker generic) { |
| super.useGeneric(generic); |
| if (generic instanceof CompoundPropertyMaker) { |
| CompoundPropertyMaker compoundGeneric = (CompoundPropertyMaker) generic; |
| for (int i = 0; i < Constants.COMPOUND_COUNT; i++) { |
| PropertyMaker submaker = compoundGeneric.subproperties[i]; |
| if (submaker != null) { |
| addSubpropMaker((PropertyMaker) submaker.clone()); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Add a subproperty to this maker. |
| * @param subproperty the sub property |
| */ |
| public void addSubpropMaker(PropertyMaker subproperty) { |
| // Place the base propId in the propId of the subproperty. |
| subproperty.propId &= Constants.COMPOUND_MASK; |
| subproperty.propId |= propId; |
| |
| subproperties[getSubpropIndex(subproperty.getPropId())] = subproperty; |
| |
| // Store the first subproperty with a setByShorthand. That subproperty |
| // will be used for converting a value set on the base property. |
| if (shorthandMaker == null && subproperty.setByShorthand) { |
| shorthandMaker = subproperty; |
| } |
| } |
| |
| |
| /** |
| * Return a Maker object which is used to set the values on components |
| * of compound property types, such as "space". |
| * Overridden by property maker subclasses which handle |
| * compound properties. |
| * @param subpropertyId the id of the component for which a Maker is to |
| * returned, for example CP_OPTIMUM, if the FO attribute is |
| * space.optimum='10pt'. |
| * @return the Maker object specified |
| */ |
| public PropertyMaker getSubpropMaker(int subpropertyId) { |
| return subproperties[getSubpropIndex(subpropertyId)]; |
| } |
| |
| /** |
| * Calculate the real value of a subproperty by unmasking and shifting |
| * the value into the range [0 - (COMPOUND_COUNT-1)]. |
| * The value is used as index into the subproperties array. |
| * @param subpropertyId the property id of the sub property. |
| * @return the array index. |
| */ |
| private int getSubpropIndex(int subpropertyId) { |
| return ((subpropertyId & Constants.COMPOUND_MASK) >> Constants.COMPOUND_SHIFT) - 1; |
| } |
| |
| /** |
| * For compound properties which can take enumerate values. |
| * Delegate the enumeration check to one of the subpropeties. |
| * @param value the string containing the property value |
| * @return the Property encapsulating the enumerated equivalent of the |
| * input value |
| */ |
| protected Property checkEnumValues(String value) { |
| Property result = null; |
| if (shorthandMaker != null) { |
| result = shorthandMaker.checkEnumValues(value); |
| } |
| if (result == null) { |
| result = super.checkEnumValues(value); |
| } |
| return result; |
| } |
| |
| /** |
| * Return the property on the current FlowObject. Depending on the passed flags, |
| * this will try to compute it based on other properties, or if it is |
| * inheritable, to return the inherited value. If all else fails, it returns |
| * the default value. |
| * @param subpropertyId The subproperty id of the property being retrieved. |
| * Is 0 when retriving a base property. |
| * @param propertyList The PropertyList object being built for this FO. |
| * @param tryInherit true if inherited properties should be examined. |
| * @param tryDefault true if the default value should be returned. |
| * @return the property |
| * @throws PropertyException if a property exception occurs |
| */ |
| public Property get(int subpropertyId, PropertyList propertyList, boolean tryInherit, |
| boolean tryDefault) throws PropertyException { |
| Property p = super.get(subpropertyId, propertyList, tryInherit, tryDefault); |
| if (subpropertyId != 0 && p != null) { |
| p = getSubprop(p, subpropertyId); |
| } |
| return p; |
| } |
| |
| /** |
| * Return a Property object based on the passed Property object. |
| * This method is called if the Property object built by the parser |
| * isn't the right type for this compound property. |
| * @param p The Property object return by the expression parser |
| * @param propertyList The PropertyList object being built for this FO. |
| * @param fo The parent FO for the FO whose property is being made. |
| * @return A Property of the correct type or null if the parsed value |
| * can't be converted to the correct type. |
| * @throws PropertyException for invalid or inconsistent FO input |
| */ |
| protected Property convertProperty(Property p, |
| PropertyList propertyList, |
| FObj fo) throws PropertyException { |
| // Delegate to the subproperty maker to do conversions. |
| p = shorthandMaker.convertProperty(p, propertyList, fo); |
| |
| if (p != null) { |
| Property prop = makeCompound(propertyList, fo); |
| CompoundDatatype pval = (CompoundDatatype) prop.getObject(); |
| for (int i = 0; i < Constants.COMPOUND_COUNT; i++) { |
| PropertyMaker submaker = subproperties[i]; |
| if (submaker != null && submaker.setByShorthand) { |
| pval.setComponent(submaker.getPropId() & Constants.COMPOUND_MASK, p, false); |
| } |
| } |
| return prop; |
| } |
| return null; |
| } |
| |
| /** |
| * Make a compound property with default values. |
| * @param propertyList The PropertyList object being built for this FO. |
| * @return the Property object corresponding to the parameters |
| * @throws PropertyException for invalid or inconsisten FO input |
| */ |
| public Property make(PropertyList propertyList) throws PropertyException { |
| if (defaultValue != null) { |
| return make(propertyList, defaultValue, propertyList.getParentFObj()); |
| } else { |
| return makeCompound(propertyList, propertyList.getParentFObj()); |
| } |
| } |
| |
| /** |
| * Create a Property object from an attribute specification. |
| * @param propertyList The PropertyList object being built for this FO. |
| * @param value The attribute value. |
| * @param fo The parent FO for the FO whose property is being made. |
| * @return The initialized Property object. |
| * @throws PropertyException for invalid or inconsistent FO input |
| */ |
| public Property make(PropertyList propertyList, String value, |
| FObj fo) throws PropertyException { |
| Property p = super.make(propertyList, value, fo); |
| p = convertProperty(p, propertyList, fo); |
| return p; |
| } |
| |
| /** |
| * Return a property value for a compound property. If the property |
| * value is already partially initialized, this method will modify it. |
| * @param baseProperty The Property object representing the compound property, |
| * for example: SpaceProperty. |
| * @param subpropertyId The Constants ID of the subproperty (component) |
| * whose value is specified. |
| * @param propertyList The propertyList being built. |
| * @param fo The parent FO for the FO whose property is being made. |
| * @param value the value of the |
| * @return baseProperty (or if null, a new compound property object) with |
| * the new subproperty added |
| * @throws PropertyException for invalid or inconsistent FO input |
| */ |
| public Property make(Property baseProperty, int subpropertyId, |
| PropertyList propertyList, String value, |
| FObj fo) throws PropertyException { |
| if (baseProperty == null) { |
| baseProperty = makeCompound(propertyList, fo); |
| } |
| |
| PropertyMaker spMaker = getSubpropMaker(subpropertyId); |
| |
| if (spMaker != null) { |
| Property p = spMaker.make(propertyList, value, fo); |
| if (p != null) { |
| return setSubprop(baseProperty, subpropertyId & Constants.COMPOUND_MASK, p); |
| } |
| } else { |
| //getLogger().error("compound property component " |
| // + partName + " unknown."); |
| } |
| return baseProperty; |
| } |
| |
| /** |
| * Create a empty compound property and fill it with default values for |
| * the subproperties. |
| * @param propertyList The propertyList being built. |
| * @param parentFO The parent FO for the FO whose property is being made. |
| * @return a Property subclass object holding a "compound" property object |
| * initialized to the default values for each component. |
| * @throws PropertyException ... |
| */ |
| protected Property makeCompound(PropertyList propertyList, FObj parentFO) |
| throws PropertyException { |
| Property p = makeNewProperty(); |
| CompoundDatatype data = (CompoundDatatype) p.getObject(); |
| for (int i = 0; i < Constants.COMPOUND_COUNT; i++) { |
| PropertyMaker subpropertyMaker = subproperties[i]; |
| if (subpropertyMaker != null) { |
| Property subproperty = subpropertyMaker.make(propertyList); |
| data.setComponent(subpropertyMaker.getPropId() |
| & Constants.COMPOUND_MASK, subproperty, true); |
| } |
| } |
| return p; |
| } |
| } |
