public virtual Filter GetFilter(XmlElement e)
        {
            string fieldName = DOMUtils.GetAttributeWithInheritanceOrFail(e, "fieldName");
            DuplicateFilter df = new DuplicateFilter(fieldName);

            string keepMode = DOMUtils.GetAttribute(e, "keepMode", "first");
            if (keepMode.Equals("first", StringComparison.OrdinalIgnoreCase))
            {
                df.KeepMode = KeepMode.KM_USE_FIRST_OCCURRENCE;
            }
            else if (keepMode.Equals("last", StringComparison.OrdinalIgnoreCase))
            {
                df.KeepMode = KeepMode.KM_USE_LAST_OCCURRENCE;
            }
            else
            {
                throw new ParserException("Illegal keepMode attribute in DuplicateFilter:" + keepMode);
            }

            string processingMode = DOMUtils.GetAttribute(e, "processingMode", "full");
            if (processingMode.Equals("full", StringComparison.OrdinalIgnoreCase))
            {
                df.ProcessingMode = ProcessingMode.PM_FULL_VALIDATION;
            }
            else if (processingMode.Equals("fast", StringComparison.OrdinalIgnoreCase))
            {
                df.ProcessingMode = ProcessingMode.PM_FAST_INVALIDATION;
            }
            else
            {
                throw new ParserException("Illegal processingMode attribute in DuplicateFilter:" + processingMode);
            }

            return df;
        }

		internal BuildItemGroup (XmlElement xmlElement, Project project, ImportedProject importedProject, bool readOnly, bool dynamic)
		{
			this.buildItems = new List <BuildItem> ();
			this.importedProject = importedProject;
			this.itemGroupElement = xmlElement;
			this.parentProject = project;
			this.read_only = readOnly;
			this.isDynamic = dynamic;
			
			if (!FromXml)
				return;

			foreach (XmlNode xn in xmlElement.ChildNodes) {
				if (!(xn is XmlElement))
					continue;
					
				XmlElement xe = (XmlElement) xn;
				BuildItem bi = CreateItem (project, xe);
				buildItems.Add (bi);
				project.LastItemGroupContaining [bi.Name] = this;
			}

			DefinedInFileName = importedProject != null ? importedProject.FullFileName :
						project != null ? project.FullFileName : null;
		}

		internal XmlElementEventArgs(XmlElement attr, int lineNum, int linePos, object source)
		{
			this.attr		= attr;
			this.lineNumber = lineNum;
			this.linePosition = linePos;
			this.obj		= source;
		}

        public static void Config(XmlElement
		    xmlElement, ref LogConfig logConfig, bool compulsory)
        {
            uint uintValue = new uint();
            int intValue = new int();

            Configuration.ConfigBool(xmlElement, "AutoRemove",
                ref logConfig.AutoRemove, compulsory);
            if (Configuration.ConfigUint(xmlElement, "BufferSize",
                ref uintValue, compulsory))
                logConfig.BufferSize = uintValue;
            Configuration.ConfigString(xmlElement, "Dir",
                ref logConfig.Dir, compulsory);
            if (Configuration.ConfigInt(xmlElement, "FileMode",
                ref intValue, compulsory))
                logConfig.FileMode = intValue;
            Configuration.ConfigBool(xmlElement, "ForceSync",
                ref logConfig.ForceSync, compulsory);
            Configuration.ConfigBool(xmlElement, "InMemory",
                ref logConfig.InMemory, compulsory);
            if (Configuration.ConfigUint(xmlElement, "MaxFileSize",
                ref uintValue, compulsory))
                logConfig.MaxFileSize = uintValue;
            Configuration.ConfigBool(xmlElement, "NoBuffer",
                ref logConfig.NoBuffer, compulsory);
            if (Configuration.ConfigUint(xmlElement, "RegionSize",
                ref uintValue, compulsory))
                logConfig.RegionSize = uintValue;
            Configuration.ConfigBool(xmlElement, "ZeroOnCreate",
                ref logConfig.ZeroOnCreate, compulsory);
        }

 // Constructor
 public CssStylesheet(XmlElement htmlElement)
 {
     if (htmlElement != null)
     {
         this.DiscoverStyleDefinitions(htmlElement);
     }
 }

        private string getNodeValue(XmlElement parentElement, string nodeName)
        {
            XmlNode node = XmlHelperFunctions.GetSubNode(parentElement, nodeName);
              if (node == null) return string.Empty;

              return node.InnerText;
        }

 //Initialize task from Weak variables
 public Task(XmlElement Element)
 {
     if (Element.Name != "Task")
         throw new Exception("Incorrect XML markup");
     this.Name = Element.GetElementsByTagName("Name")[0].InnerText;
     this.GroupName = Element.GetElementsByTagName("GroupName")[0].InnerText;
     this.Description = Element.GetElementsByTagName("Description")[0].InnerText;
     this.Active = Element.GetElementsByTagName("Active")[0].InnerText == "1";
     XmlElement TriggersElement = (XmlElement)Element.GetElementsByTagName("Triggers")[0];
     foreach (XmlElement TriggerElement in TriggersElement.ChildNodes)
     {
         Trigger Trigger = new Trigger(TriggerElement);
         Triggers.Add(Trigger);
         Trigger.AssignTask(this);
     }
     XmlElement ConditionsElement = (XmlElement)Element.GetElementsByTagName("Conditions")[0];
     foreach (XmlElement ConditionElement in ConditionsElement.ChildNodes)
     {
         Condition Condition = new Condition(ConditionElement);
         Conditions.Add(Condition);
         Condition.AssignTask(this);
     }
     XmlElement ActionsElement = (XmlElement)Element.GetElementsByTagName("Actions")[0];
     foreach (XmlElement ActionElement in ActionsElement.ChildNodes)
     {
         Actions.Action Action = new Actions.Action(ActionElement);
         Actions.Add(Action);
         Action.AssignTask(this);
     }
 }

 public void CreateXmlElement()
 {
     XmlDocument xmlDoc = new XmlDocument();
     string xmlData = "<objects xmlns=\"http://www.springframework.net\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://www.springframework.net http://www.springframework.net/xsd/spring-objects.xsd\"><object name=\"TestVersion\"  type=\"System.Version, Mscorlib\"></object></objects>";
     xmlDoc.Load(new StringReader(xmlData));
     _xmlElement = xmlDoc.DocumentElement;
 }

 public GObjectVM(XmlElement elem, ObjectBase container_type)
     : base(elem, container_type)
 {
     parms.HideData = false;
     this.Protection = "protected";
     class_struct_name = container_type.ClassStructName;
 }

        public ManagedProjectReference(XmlElement xmlDefinition, ReferencesResolver referencesResolver, ProjectBase parent, SolutionBase solution, TempFileCollection tfc, GacCache gacCache, DirectoryInfo outputDir)
            : base(referencesResolver, parent)
        {
            if (xmlDefinition == null) {
                throw new ArgumentNullException("xmlDefinition");
            }
            if (solution == null) {
                throw new ArgumentNullException("solution");
            }
            if (tfc == null) {
                throw new ArgumentNullException("tfc");
            }
            if (gacCache == null) {
                throw new ArgumentNullException("gacCache");
            }

            XmlAttribute privateAttribute = xmlDefinition.Attributes["Private"];
            if (privateAttribute != null) {
                _isPrivateSpecified = true;
                _isPrivate = bool.Parse(privateAttribute.Value);
            }

            // determine path of project file
            string projectFile = solution.GetProjectFileFromGuid(
                xmlDefinition.GetAttribute("Project"));

            // load referenced project
            _project = LoadProject(solution, tfc, gacCache, outputDir, projectFile);
        }

        protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
        {

            builder.AddPropertyReference(TxNamespaceUtils.TRANSACTION_MANAGER_PROPERTY,
                GetAttributeValue(element, TxNamespaceUtils.TRANSACTION_MANAGER_ATTRIBUTE));
            XmlNodeList txAttributes = element.SelectNodes("*[local-name()='attributes' and namespace-uri()='" + element.NamespaceURI + "']");
            if (txAttributes.Count > 1 )
            {
                parserContext.ReaderContext.ReportException(element, "tx advice", "Element <attributes> is allowed at most once inside element <advice>");
            }
            else if (txAttributes.Count == 1)
            {
                //using xml defined source
                XmlElement attributeSourceElement = txAttributes[0] as XmlElement;
                AbstractObjectDefinition attributeSourceDefinition =
                    ParseAttributeSource(attributeSourceElement, parserContext);
                builder.AddPropertyValue(TxNamespaceUtils.TRANSACTION_ATTRIBUTE_SOURCE, attributeSourceDefinition);
            }
            else
            {
                //Assume attibutes source
                ObjectDefinitionBuilder txAttributeSourceBuilder = 
                    parserContext.ParserHelper.CreateRootObjectDefinitionBuilder(typeof (AttributesTransactionAttributeSource));

                builder.AddPropertyValue(TxNamespaceUtils.TRANSACTION_ATTRIBUTE_SOURCE,
                                         txAttributeSourceBuilder.ObjectDefinition);

            }
        }

        protected override void AddCompositeIdGenerator(XmlDocument xmldoc, XmlElement idElement, List<ColumnDetail> compositeKey, ApplicationPreferences applicationPreferences)
        {
            foreach (ColumnDetail column in compositeKey)
            {
                var keyElement = xmldoc.CreateElement("key-property");
                string propertyName =
                    column.ColumnName.GetPreferenceFormattedText(applicationPreferences);

                if (applicationPreferences.FieldGenerationConvention == FieldGenerationConvention.Property)
                {
                    idElement.SetAttribute("name", propertyName.MakeFirstCharLowerCase());
                }
                else
                {
                    if (applicationPreferences.FieldGenerationConvention == FieldGenerationConvention.AutoProperty)
                    {
                        propertyName = column.ColumnName.GetFormattedText();
                    }

                    keyElement.SetAttribute("name", propertyName);
                }
                var mapper = new DataTypeMapper();
                Type mapFromDbType = mapper.MapFromDBType(column.DataType, column.DataLength,
                                                          column.DataPrecision,
                                                          column.DataScale);
                keyElement.SetAttribute("type", mapFromDbType.Name);
                keyElement.SetAttribute("column", column.ColumnName);
                if (applicationPreferences.FieldGenerationConvention != FieldGenerationConvention.AutoProperty)
                {
                    keyElement.SetAttribute("access", "field");
                }
                idElement.AppendChild(keyElement);
            }
        }

        public static void Load( XmlElement xml )
        {
            DisableAll();

            if ( xml == null )
                return;

            foreach( XmlElement el in xml.GetElementsByTagName( "filter" ) )
            {
                try
                {
                    LocString name = (LocString)Convert.ToInt32( el.GetAttribute( "name" ) );
                    string enable = el.GetAttribute( "enable" );

                    for(int i=0;i<m_Filters.Count;i++)
                    {
                        Filter f = (Filter)m_Filters[i];
                        if ( f.Name == name )
                        {
                            if ( Convert.ToBoolean( enable ) )
                                f.OnEnable();
                            break;
                        }
                    }
                }
                catch
                {
                }
            }
        }

		LayoutConfiguration(XmlElement el, bool custom)
		{
			name       = el.GetAttribute("name");
			fileName   = el.GetAttribute("file");
			readOnly   = Boolean.Parse(el.GetAttribute("readonly"));
			this.custom = custom;
		}

 public static ProjectTemplatePackageReference Create(XmlElement xmlElement)
 {
     return new ProjectTemplatePackageReference {
         Id = GetAttribute (xmlElement, "id"),
         Version = GetAttribute (xmlElement, "version")
     };
 }

        /// <summary>
        /// 递归函数，根据规则依次调整每个Mind位置
        /// </summary>
        /// <param name="xmle">当前节点</param>
        /// <param name="point">当前节点位置</param>
        /// <returns>调整后当前节点大小和位置</returns>
        private Point Recursion_AdjustMindModel(XmlElement xmle, Point point)
        {
            // 本级区域
            Rectangle rect = new Rectangle(point, new Size(20 * xmle.GetAttribute("key").Length, 20));
            // 下一个子集定位点
            Point nextChildPoint = new Point(rect.Right, rect.Top);
            // 下一个本级定位点
            Point nextPoint = new Point(rect.Left, rect.Bottom);

            if (xmle.HasChildNodes)
            {
                foreach (XmlElement txmle in xmle.ChildNodes)
                {
                    nextChildPoint = Recursion_AdjustMindModel(txmle, nextChildPoint);
                    nextPoint.Y = nextChildPoint.Y;
                }
                Rectangle firstChildRect = MindConvert.StringToRectangle(((XmlElement)xmle.FirstChild).GetAttribute("region"));
                Rectangle lastChildRect = MindConvert.StringToRectangle(((XmlElement)xmle.LastChild).GetAttribute("region"));
                rect.Offset(0, (lastChildRect.Top + firstChildRect.Top) / 2 - rect.Top);
            }

            xmle.SetAttribute("region", MindConvert.RectangleToString(rect));

            return nextPoint;
        }

		internal XmlAttributeCollection (XmlNode parent) : base (parent)
		{
			ownerElement = parent as XmlElement;
			ownerDocument = parent.OwnerDocument;
			if(ownerElement == null)
				throw new XmlException ("invalid construction for XmlAttributeCollection.");
		}

 protected ContentControl(GuiSystem guiSystem, XmlElement element) : base(guiSystem, element)
 {
     if (element.HasChildNodes)
     {
         Child = CreateFromXmlType(guiSystem, (XmlElement)element.FirstChild);
     }
 }

        protected override void SaveNode(XmlDocument xmlDoc, XmlElement nodeElement, SaveContext context)
        {
            Controller.SaveNode(xmlDoc, nodeElement, context);
            
            var outEl = xmlDoc.CreateElement("Name");
            outEl.SetAttribute("value", NickName);
            nodeElement.AppendChild(outEl);

            outEl = xmlDoc.CreateElement("Description");
            outEl.SetAttribute("value", Description);
            nodeElement.AppendChild(outEl);

            outEl = xmlDoc.CreateElement("Inputs");
            foreach (string input in InPortData.Select(x => x.NickName))
            {
                XmlElement inputEl = xmlDoc.CreateElement("Input");
                inputEl.SetAttribute("value", input);
                outEl.AppendChild(inputEl);
            }
            nodeElement.AppendChild(outEl);

            outEl = xmlDoc.CreateElement("Outputs");
            foreach (string output in OutPortData.Select(x => x.NickName))
            {
                XmlElement outputEl = xmlDoc.CreateElement("Output");
                outputEl.SetAttribute("value", output);
                outEl.AppendChild(outputEl);
            }
            nodeElement.AppendChild(outEl);
        }

		internal Target (XmlElement targetElement, Project project, ImportedProject importedProject)
		{
			if (project == null)
				throw new ArgumentNullException ("project");
			if (targetElement == null)
				throw new ArgumentNullException ("targetElement");

			this.targetElement = targetElement;
			this.name = targetElement.GetAttribute ("Name");

			this.project = project;
			this.engine = project.ParentEngine;
			this.importedProject = importedProject;

			this.onErrorElements  = new List <XmlElement> ();
			this.buildState = BuildState.NotStarted;
			this.buildTasks = new List <BuildTask> ();
			this.batchingImpl = new TargetBatchingImpl (project, this.targetElement);

			bool onErrorFound = false;
			foreach (XmlNode xn in targetElement.ChildNodes) {
				if (xn is XmlElement) {
					XmlElement xe = (XmlElement) xn;
					if (xe.Name == "OnError") {
						onErrorElements.Add (xe);
						onErrorFound = true;
					} else if (onErrorFound)
						throw new InvalidProjectFileException (
							"The element <OnError> must be last under element <Target>. Found element <Error> instead.");
					else
						buildTasks.Add (new BuildTask (xe, this));
				}
			}
		}