protected override Property convertValueForProperty(
     string propName, PropertyMaker maker, PropertyList propertyList)
 {
     Property p = null;
     if (propName.IndexOf("-top") >= 0)
     {
         p = getElement(0);
     }
     else if (propName.IndexOf("-right") >= 0)
     {
         p = getElement(count() > 1 ? 1 : 0);
     }
     else if (propName.IndexOf("-bottom") >= 0)
     {
         p = getElement(count() > 2 ? 2 : 0);
     }
     else if (propName.IndexOf("-left") >= 0)
     {
         p = getElement(count() > 3 ? 3 : (count() > 1 ? 1 : 0));
     }
     if (p != null)
     {
         return maker.ConvertShorthandProperty(propertyList, p, null);
     }
     return p;
 }

        protected PageSequenceMaster(FObj parent, PropertyList propertyList)
            : base(parent, propertyList)
        {
            this.name = "fo:page-sequence-master";

            subSequenceSpecifiers = new ArrayList();

            if (parent.GetName().Equals("fo:layout-master-set"))
            {
                this.layoutMasterSet = (LayoutMasterSet)parent;
                string pm = this.properties.GetProperty("master-name").GetString();
                if (pm == null)
                {
                    FonetDriver.ActiveDriver.FireFonetWarning(
                        "page-sequence-master does not have a page-master-name and so is being ignored");
                }
                else
                {
                    this.layoutMasterSet.addPageSequenceMaster(pm, this);
                }
            }
            else
            {
                throw new FonetException("fo:page-sequence-master must be child "
                    + "of fo:layout-master-set, not "
                    + parent.GetName());
            }
        }

        public override Property Make(PropertyList propertyList) {
            if (m_defaultProp == null) {
                m_defaultProp = Make(propertyList, "0", propertyList.getParentFObj());
            }
            return m_defaultProp;

        }

        public Block(FObj parent, PropertyList propertyList) : base(parent, propertyList)
        {
            this.name = "fo:block";

            switch (parent.GetName())
            {
                case "fo:basic-link":
                case "fo:block":
                case "fo:block-container":
                case "fo:float":
                case "fo:flow":
                case "fo:footnote-body":
                case "fo:inline":
                case "fo:inline-container":
                case "fo:list-item-body":
                case "fo:list-item-label":
                case "fo:marker":
                case "fo:multi-case":
                case "fo:static-content":
                case "fo:table-caption":
                case "fo:table-cell":
                case "fo:wrapper":
                    break;
                default:
                    throw new FonetException(
                        "fo:block must be child of " +
                            "fo:basic-link, fo:block, fo:block-container, fo:float, fo:flow, fo:footnote-body, fo:inline, fo:inline-container, fo:list-item-body, fo:list-item-label, fo:marker, fo:multi-case, fo:static-content, fo:table-caption, fo:table-cell or fo:wrapper " +
                            "not " + parent.GetName());
            }
            this.span = this.properties.GetProperty("span").GetEnum();
            ts = propMgr.getTextDecoration(parent);
        }

        public Flusso(Variable father, string[] fields, List<string> map)
        {
            this.father = father;
            protocolname = map[0];
            propertyDefinitions = VarDefinitions.Map[map[0]];
            propertyValues = new PropertyList();
            if (Regex.IsMatch(map[0], "Variables|Common", RegexOptions.IgnoreCase))
                name = map[0];
            else
                name = fields[1];

            name = name.Trim();
            foreach (var pt in propertyDefinitions)
            {
                if (!pt.Value.Visibile) continue;
                int i = map.FindIndex(x => x == pt.Key);
                if (pt.Key=="Abilitato")
                {
                    if (!Boolean.TryParse(fields[i-1], out abilitazione)) abilitazione = false;
                }
                if (i > 0)
                {
                    propertyValues.Add(pt.Key, fields[i - 1].Replace("%sc%",";").Trim(),pt.Value);
                }
                else
                    propertyValues.Add(pt.Key, "", pt.Value);
            }   
        }

 public ProjectInfo(Project project)
 {
     _project = project;
     _properties = new ProjectPropertyList(_project);
     _references = new ReferenceList(_project);
     _dependencies = new List<string>();
 }

        public AddEditPropertyListDialog(PropertyList propertyList)
        {
            InitializeComponent();
            Title = "Edit Component Property List";

            mViewPropertyList = new AddEditPropertyListViewModel(this, propertyList);
        }

        protected SimplePageMaster(FObj parent, PropertyList propertyList)
            : base(parent, propertyList)
        {
            this.name = "fo:simple-page-master";

            if (parent.GetName().Equals("fo:layout-master-set"))
            {
                this.layoutMasterSet = (LayoutMasterSet)parent;
                masterName = this.properties.GetProperty("master-name").GetString();
                if (masterName == null)
                {
                    FonetDriver.ActiveDriver.FireFonetWarning(
                        "simple-page-master does not have a master-name and so is being ignored");
                }
                else
                {
                    this.layoutMasterSet.addSimplePageMaster(this);
                }
            }
            else
            {
                throw new FonetException("fo:simple-page-master must be child "
                    + "of fo:layout-master-set, not "
                    + parent.GetName());
            }
            _regions = new Hashtable();
        }

        public override Property GetShorthand(PropertyList propertyList) {
            Property p = null;
            ListProperty listprop;

            if (p == null) {
                listprop = (ListProperty) propertyList.GetExplicitProperty("border-top");
                if (listprop != null) {
                    IShorthandParser shparser = new GenericShorthandParser(listprop);
                    p = shparser.GetValueForProperty(PropName, this, propertyList);
                }
            }

            if (p == null) {
                listprop = (ListProperty) propertyList.GetExplicitProperty("border-width");
                if (listprop != null) {
                    IShorthandParser shparser = new BoxPropShorthandParser(listprop);
                    p = shparser.GetValueForProperty(PropName, this, propertyList);
                }
            }

            if (p == null) {
                listprop = (ListProperty) propertyList.GetExplicitProperty("border");
                if (listprop != null) {
                    IShorthandParser shparser = new GenericShorthandParser(listprop);
                    p = shparser.GetValueForProperty(PropName, this, propertyList);
                }
            }

            return p;
        }

        public override Property Compute(PropertyList propertyList)
        {
            Property computedProperty = null;
            Property correspondingProperty = propertyList.GetProperty("text-align");
            if (correspondingProperty != null)
            {
                int correspondingValue = correspondingProperty.GetEnum();

                if (correspondingValue == TextAlign.JUSTIFY)
                {
                    computedProperty = new EnumProperty(Constants.START);
                }
                else if (correspondingValue == TextAlign.END)
                {
                    computedProperty = new EnumProperty(Constants.END);
                }
                else if (correspondingValue == TextAlign.START)
                {
                    computedProperty = new EnumProperty(Constants.START);
                }
                else if (correspondingValue == TextAlign.CENTER)
                {
                    computedProperty = new EnumProperty(Constants.CENTER);
                }

            }
            return computedProperty;
        }

        protected Flow(FObj parent, PropertyList propertyList)
            : base(parent, propertyList)
        {
            this.name = GetElementName();

            if (parent.GetName().Equals("fo:page-sequence"))
            {
                this.pageSequence = (PageSequence)parent;
            }
            else
            {
                throw new FonetException("flow must be child of "
                    + "page-sequence, not "
                    + parent.GetName());
            }
            SetFlowName(GetProperty("flow-name").GetString());

            if (pageSequence.IsFlowSet)
            {
                if (this.name.Equals("fo:flow"))
                {
                    throw new FonetException("Only a single fo:flow permitted"
                        + " per fo:page-sequence");
                }
                else
                {
                    throw new FonetException(this.name
                        + " not allowed after fo:flow");
                }
            }
            pageSequence.AddFlow(this);
        }

 public AbstractTableBody(FObj parent, PropertyList propertyList) : base(parent, propertyList)
 {
     if (!(parent is Table))
     {
         FonetDriver.ActiveDriver.FireFonetError(
             "A table body must be child of fo:table, not " + parent.GetName());
     }
 }

 public override Property Make(PropertyList propertyList)
 {
     if (m_defaultProp == null)
     {
         m_defaultProp = Make(propertyList, "use-target-processing-context", propertyList.getParentFObj());
     }
     return m_defaultProp;
 }

 public virtual void LoadExternalFile(string path)
 {
     ExternalFile = path;
     if (string.IsNullOrEmpty(path))
         Properties = new PropertyList();
     else
         Properties = environmentLoader.LoadProperties(path);
 }

        public BuildEngine(FrameworkVersions toolsVersion, string frameworkPath)
        {
            _framework = toolsVersion;
            _frameworkPath = frameworkPath;
			Engine = CreateEngine(_framework, _frameworkPath);
            _projects = new ProjectList(this, _framework);
            _properties = new PropertyList(Engine.GlobalProperties);
        }

        public DataRecordConverterTypeBuilder(DataRecordConverterSpec queryInfo)
        {
            _queryInfo = Verify.ArgumentNotNull(queryInfo, "queryInfo");

            PropertyInfo[] properties = queryInfo.RecordType.GetProperties();

            var propertyMap = new NameDictionary<PropertyInfo>();
            var dataRecordMap = new NameDictionary<DataRecordFieldInfo>();

            foreach (DataRecordFieldInfo field in queryInfo.Fields)
            {
                dataRecordMap.Add(field.FieldName, field);
            }

            foreach (PropertyInfo property in properties)
            {
                if (property.HasPublicSetter())
                {
                    propertyMap.Add(property.Name, property);
                }
            }

            foreach (DataRecordFieldInfo field in queryInfo.Fields)
            {
                var propertyList = new PropertyList(queryInfo.RecordType, field.FieldName);
                if (propertyList.HasErrors)
                {
                    _errors.AddRange(propertyList.Errors);
                }
                else if (DataRecordConverterMethod.CanHandleConversion(field.FieldType, propertyList.PropertyType))
                {
                    _mapFieldToProperty.Add(field, propertyList);
                }
                else
                {
                    _errors.Add(string.Format("Cannot convert from {0} to {1} for {2}",
                                              field.FieldType.Name, propertyList.PropertyType.Name, field.FieldName));
                }
            }

            foreach (PropertyInfo property in properties)
            {
                if (property.HasPublicSetter())
                {
                    DataRecordFieldInfo field;
                    if (dataRecordMap.TryGetValue(property.Name, out field))
                    {
                        _mapPropertyToField.Add(property, field);
                    }
                    else
                    {
                        _errors.Add(string.Format("Query result does not have a column named '{0}'",
                                                  property.Name));
                    }
                }
            }
        }

        public void CreateNewPropertyWithBestInitialValues_InitialListTest()
        {
            var properties = new PropertyList();

            var newProperty = properties.CreateNew(_classifiers);

            Assert.AreEqual("New Property 1", newProperty.Name);
            Assert.AreEqual(String, newProperty.Type);
        }

 public virtual PropertyList LoadProperties(string path)
 {
     var xml = XElement.Parse(fileSystem.ReadAllText(path));
     var result = new PropertyList();
     var propertyNodes = xml.Descendants(ScopedName("PropertyGroup")).Descendants();
     foreach (var node in propertyNodes)
         result.Add(node.Name.LocalName, node.Value);
     return result;
 }

        protected InlineContainer(FObj parent, PropertyList propertyList)
            : base(parent, propertyList)
        {
            this.name = "fo:inline-container";

            BorderAndPadding bap = propMgr.GetBorderAndPadding();
            BackgroundProps bProps = propMgr.GetBackgroundProps();
            MarginInlineProps mProps = propMgr.GetMarginInlineProps();
            RelativePositionProps mRelProps = propMgr.GetRelativePositionProps();
        }

 protected override Property ConvertPropertyDatatype(
     Property p, PropertyList propertyList, FObj fo)
 {
     String nameval = p.GetNCname();
     if (nameval != null)
     {
         return new ColorTypeProperty(new ColorType(nameval));
     }
     return base.ConvertPropertyDatatype(p, propertyList, fo);
 }