protected StringPropertyEditorBase(Type objectType, DictionaryNode info)
     : base(objectType, info)
 {
     if (string.IsNullOrEmpty(info.GetAttributeValue(DetailViewItemInfoNodeWrapper.ImmediatePostDataAttribute))){
         ImmediatePostData = true;
     }
 }

 private DictionaryNode GetNewVariantNode(DictionaryNode variantsNode, PopupWindowShowActionExecuteEventArgs e, out ViewCloner viewCloner) {
     DictionaryNode newVariantNode = variantsNode.AddChildNode("Variant");
     viewCloner = ((ViewCloner) e.PopupWindow.View.CurrentObject);
     newVariantNode.SetAttribute("ViewID", viewCloner.Caption);
     setAttributes(newVariantNode, viewCloner);
     return newVariantNode;
 }

        public static void AddFields(DictionaryNode rootNode, XPDictionary dictionary)
        {
            foreach (PropertyInfoNodeWrapper customFieldInfo in GetCustomFields(rootNode))
                try
                {
                    Type classType = ReflectionHelper.GetType(customFieldInfo.Class.Name);
                    var typeInfo = dictionary.GetClassInfo(classType);
                    lock (typeInfo)
                    {
                        if (typeInfo.FindMember(customFieldInfo.Name) == null)
                        {
                            Type memberType = ReflectionHelper.GetType(customFieldInfo.Type);
                            XPCustomMemberInfo memberInfo = typeInfo.CreateMember(customFieldInfo.Name, memberType);
                            if (customFieldInfo.Size != 0)
                                memberInfo.AddAttribute(new DevExpress.Xpo.SizeAttribute(customFieldInfo.Size));

                            XafTypesInfo.Instance.RefreshInfo(classType);
                        }
                    }
                }
                catch (Exception exception)
                {
                    throw new Exception(
                        ExceptionLocalizerTemplate<SystemExceptionResourceLocalizer, ExceptionId>.GetExceptionMessage(
                            ExceptionId.ErrorOccursWhileAddingTheCustomProperty,
                            customFieldInfo.Type,
                            customFieldInfo.Class.Name,
                            customFieldInfo.Name,
                            exception.Message));
                }
        }

 public string GetCurrentAspectXml(DictionaryNode node)
 {
     if (node.Dictionary == null){
         return GetAspectXml(DictionaryAttribute.DefaultLanguage, node);
     }
     return GetAspectXml(node.Dictionary.CurrentAspect, node);
 }

 public void Add(object key, object value)
 {
     if (key == null)
     {
         throw new ArgumentNullException("key", SR.GetString("ArgumentNull_Key"));
     }
     this.version++;
     DictionaryNode node = null;
     for (DictionaryNode node2 = this.head; node2 != null; node2 = node2.next)
     {
         object x = node2.key;
         if ((this.comparer == null) ? x.Equals(key) : (this.comparer.Compare(x, key) == 0))
         {
             throw new ArgumentException(SR.GetString("Argument_AddingDuplicate"));
         }
         node = node2;
     }
     DictionaryNode node3 = new DictionaryNode {
         key = key,
         value = value
     };
     if (node != null)
     {
         node.next = node3;
     }
     else
     {
         this.head = node3;
     }
     this.count++;
 }

        protected override ReadOnlyDictionaryNodeCollection GetNodesCollectionInternal(DictionaryNode node, string attributeName)
        {
            var collectionInternal = new DictionaryNodeCollection();
            collectionInternal.AddRange(new ApplicationNodeWrapper(node.Dictionary.RootNode).Node.GetChildNode(ModuleController.Modules).ChildNodes);
            return collectionInternal;


        }

 public string GetAspectXml(string aspect, DictionaryNode node, bool includeChildNodes)
 {
     string result = GetAspectXml(aspect, node, 0, includeChildNodes);
     if (string.IsNullOrEmpty(result) && IsDefaultAspect(aspect, node)){
         result = string.Format("<{0} />\r\n", node.Name);
     }
     return result;
 }

        public Object this[Object key] {
            get {
                if (key == null) {
                    throw new ArgumentNullException("key", Environment.GetResourceString("ArgumentNull_Key"));
                }
                Contract.EndContractBlock();
                DictionaryNode node = head;

                while (node != null) {
                    if ( node.key.Equals(key) ) {
                        return node.value;
                    }
                    node = node.next;
                }
                return null;
            }
            set {
                if (key == null) {
                    throw new ArgumentNullException("key", Environment.GetResourceString("ArgumentNull_Key"));
                }
                Contract.EndContractBlock();

#if FEATURE_SERIALIZATION
                if (!key.GetType().IsSerializable)                 
                    throw new ArgumentException(Environment.GetResourceString("Argument_NotSerializable"), "key");                    

                if( (value != null) && (!value.GetType().IsSerializable ) )
                    throw new ArgumentException(Environment.GetResourceString("Argument_NotSerializable"), "value");                    
#endif
                
                version++;
                DictionaryNode last = null;
                DictionaryNode node;
                for (node = head; node != null; node = node.next) {
                    if( node.key.Equals(key) ) {
                        break;
                    } 
                    last = node;
                }
                if (node != null) {
                    // Found it
                    node.value = value;
                    return;
                }
                // Not found, so add a new one
                DictionaryNode newNode = new DictionaryNode();
                newNode.key = key;
                newNode.value = value;
                if (last != null) {
                    last.next = newNode;
                }
                else {
                    head = newNode;
                }
                count++;
            }
        }

        private static ICollection<PropertyInfoNodeWrapper> GetCustomFields(DictionaryNode applicationNode)
        {
            var result = new List<PropertyInfoNodeWrapper>();
            foreach (DictionaryNode node in applicationNode.GetChildNode(BOModelNodeWrapper.NodeName).GetChildNodes(PropertyInfoNodeWrapper.NodeName, IsRuntimeMember, bool.TrueString, true))
            {
                result.Add(new PropertyInfoNodeWrapper(node));
            }

            return result;
        }

        public void Create_Application()
        { 
            var helper = new SchemaHelper();

            DictionaryNode node=helper.CreateElement(ModelElement.Application);

            var dictionaryNode = new DictionaryNode("Element");
            dictionaryNode.SetAttribute("Name", ModelElement.Application.ToString());
            Assert.AreEqual(dictionaryNode.ToXml(), node.ToXml());
        }

        protected override ReadOnlyDictionaryNodeCollection GetNodesCollectionInternal(DictionaryNode node, string attributeName)
        {
            var allNodes = base.GetNodesCollectionInternal(node, attributeName);
            var result = new DictionaryNodeCollection();
            var nonStringProperties = allNodes.Where(n => n.GetAttributeValue("Type").Equals(typeof(string).FullName));
            
            foreach (var stringProperty in nonStringProperties)
            {
                result.Add(stringProperty);
            }

            return result;
        }

        public void Create_Class()
        {
            var helper = new SchemaHelper();

            DictionaryNode node=helper.CreateElement(ModelElement.Class);

            var dictionaryNode = new DictionaryNode("Element");
            dictionaryNode.SetAttribute("Name", ModelElement.Application.ToString());
            var childNode = dictionaryNode.AddChildNode("Element");
            childNode.SetAttribute("Name", ModelElement.BOModel.ToString());
            childNode.AddChildNode("Element").SetAttribute("Name", ModelElement.Class.ToString());
            

            Assert.AreEqual(dictionaryNode.ToXml(), node.ToXml());
        }

 public override bool IsInvisible(DictionaryNode node, string attributeName)
 {
     var attributeValueByPath = helper.GetAttributeValueByPath(node, helper.GetParamValue("ID", "@ID"));
     if (!string.IsNullOrEmpty(attributeValueByPath))
     {
         var wrapper = new ApplicationNodeWrapper(node.Dictionary).Views.FindViewById(attributeValueByPath);
         if ((helper.GetParamValue("ViewType") == ViewType.DetailView.ToString() && wrapper is DetailViewInfoNodeWrapper) ||
             (helper.GetParamValue("ViewType") == ViewType.ListView.ToString() && wrapper is ListViewInfoNodeWrapper))
             return true;
         if (helper.GetParamValue("ViewType") == ViewType.Any.ToString() && wrapper != null)
             return true;
     }
     
     return false;
 }

 public void Add(object key, object value)
 {
     if (key == null)
     {
         throw new ArgumentNullException("key", Environment.GetResourceString("ArgumentNull_Key"));
     }
     if (!key.GetType().IsSerializable)
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_NotSerializable"), "key");
     }
     if ((value != null) && !value.GetType().IsSerializable)
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_NotSerializable"), "value");
     }
     this.version++;
     DictionaryNode node = null;
     DictionaryNode head = this.head;
     while (head != null)
     {
         if (head.key.Equals(key))
         {
             throw new ArgumentException(Environment.GetResourceString("Argument_AddingDuplicate__", new object[] { head.key, key }));
         }
         node = head;
         head = head.next;
     }
     if (head != null)
     {
         head.value = value;
     }
     else
     {
         DictionaryNode node3 = new DictionaryNode {
             key = key,
             value = value
         };
         if (node != null)
         {
             node.next = node3;
         }
         else
         {
             this.head = node3;
         }
         this.count++;
     }
 }

 protected override ReadOnlyDictionaryNodeCollection GetNodesCollectionInternal(DictionaryNode node,
                                                                                string attributeName) {
     var result = new DictionaryNodeCollection();
     DictionaryNode classesNode = node.Dictionary.RootNode.FindChildNode(BOModelNodeWrapper.NodeName);
     if (classesNode != null) {
         string typeName = parser.GetAttributeValueByPath(node, classNameAttrPath);
         DictionaryNode classNode = classesNode.FindChildNode(ClassInfoNodeWrapper.NameAttribute, typeName);
         Type type = ReflectionHelper.GetType(typeName);
         result.Add(classNode);
         foreach (DictionaryNode checkNode in classesNode.ChildNodes) {
             Type checkType = ReflectionHelper.GetType(checkNode.GetAttributeValue("Name"));
             if (checkType.IsSubclassOf(type) || type.IsSubclassOf(checkType)) {
                 result.Add(checkNode);
             }
         }
     }
     return result;
 }

            public void Load_From_Directory()
            {

                Isolate.Fake.StaticMethods(typeof(Validator));
                var store = new XpoModelDictionaryDifferenceStoreFactory<XpoWinModelDictionaryDifferenceStore>().Create(
                                                                         Isolate.Fake.Instance<XafApplication>(), true);
                #region isolate store
                Isolate.WhenCalled(() => store.GetModelPaths()).WillReturn(new List<string> { "model.xafml", "model_el.xafml", "LogonParameters.xafml" });
                Isolate.WhenCalled(() => store.UseModelFromPath()).WillReturn(true);
                Isolate.WhenCalled(() => store.SaveDifference(null)).IgnoreCall();
                #endregion
                var dictionaryNode = new DictionaryNode("Application");
                #region isolate dictionaryXmlReader
                var dictionaryXmlReader = Isolate.Fake.Instance<DictionaryXmlReader>();
                Isolate.Swap.AllInstances<DictionaryXmlReader>().With(dictionaryXmlReader);
                Isolate.WhenCalled(() => dictionaryXmlReader.ReadFromFile(null)).WillReturn(dictionaryNode);
                #endregion

                Dictionary dictionary = store.LoadDifference(Schema.GetCommonSchema());


                Assert.AreEqual(dictionaryNode.ToXml(), dictionary.RootNode.ToXml());
            }

		private DictionaryNode FindEntry (object key, out DictionaryNode prev)
		{
			if (key == null)
				throw new ArgumentNullException ("key", "Attempted lookup for a null key.");

			DictionaryNode entry = head;
			prev = null;
			if (comparer == null) {
				while (entry != null) {
					if (key.Equals (entry.key))
						break;
					prev = entry;
					entry = entry.next;
				}
			} else {
				while (entry != null) {
					if (comparer.Compare (key, entry.key) == 0)
						break;
					prev = entry;
					entry = entry.next;
				}
			}
			return entry;
		}

 public IntegerPropertyEditor(Type objectType, DictionaryNode info) : base(objectType, info)
 {
 }

        /// <summary>
        /// Sets property into the container.
        /// </summary>
        /// <param name="key">Key.</param>
        /// <param name="value">Value.</param>
        public void SetProperty(object key, object value)
        {
            CheckKey(key);

            //
            object p = _type;

            // empty list
            if (p == null)
            {
                _type = key;
                _obj = value;
            }
            // one item list, with the same key
            else if (p == key)
            {
                _obj = value;
            }
            // linked list
            else if (object.ReferenceEquals(p, TypeList))
            {
                Debug.Assert(_obj is DictionaryNode);

                // replaces value if key already in collection,
                // counts items
                int count = 0;
                for (var node = (DictionaryNode)_obj; node != null; node = node.next)
                {
                    if (node.key == key)
                    {
                        node.value = value;
                        return;
                    }
                    count++;
                }

                // add new item
                if (count < MaxListSize)
                {
                    _obj = new DictionaryNode() { key = key, value = value, next = (DictionaryNode)_obj };
                }
                else
                {
                    // upgrade to hashtable
                    var hashtable = ToHashtable((DictionaryNode)_obj);
                    hashtable.Add(key, value);

                    _obj = hashtable;
                    _type = TypeHashtable;
                }
            }
            // hashtable
            else if (object.ReferenceEquals(p, TypeHashtable))
            {
                Debug.Assert(_obj is Hashtable);
                ((Hashtable)_obj)[key] = value;
            }
            // one item list,
            // upgrade to linked list
            else
            {
                _obj = new DictionaryNode()
                {
                    key = _type,
                    value = _obj,
                    next = new DictionaryNode()
                    {
                        key = key,
                        value = value,
                        next = null,
                    }
                };
                _type = TypeList;
            }
        }

 private static DictionaryNode ToList(Hashtable/*!*/hashtable)
 {
     DictionaryNode list = null;
     foreach (DictionaryEntry p in hashtable)
     {
         list = new DictionaryNode() { key = p.Key, value = p.Value, next = list };
     }
     return list;
 }