コード例 #1
0
        /// <summary>
        /// Adds a field to the parent <see cref="ObjectFieldCollection"/>.
        /// </summary>
        /// <param name="field">The field to add.</param>
        private void AddNewEntry(ObjectField field)
        {
            object newValue = GetNewValue(field);

            ObjectFieldDictionary parentDictionary = field as ObjectFieldDictionary;

            if (parentDictionary != null)
            {
                // Find a new key value
                string key;
                for (int i = 1; ; ++i)
                {
                    key = "Key" + i;
                    if (!parentDictionary.Items.ContainsKey(key))
                    {
                        break;
                    }
                }

                ObjectField newField = ModelCreator.CreateObjectField("[" + key + "]", newValue, parentDictionary);
                newField.NameTag = key;
                parentDictionary.Add(newField);
                return;
            }

            ObjectFieldList parentList = field as ObjectFieldList;

            if (parentList != null)
            {
                ObjectField newField = ModelCreator.CreateObjectField("[" + (parentList.Items.Count + 1) + "]", newValue, parentList);
                parentList.Add(newField);
            }
        }
コード例 #2
0
        private ObjectFieldDictionary CreateObjectFieldDictionary(string name, Type type, PropertyInfo property, IDictionary dictionary)
        {
            ObjectFieldDictionary field = new ObjectFieldDictionary
            {
                Name         = name,
                IsNullable   = true,
                PropertyInfo = property,
                Type         = type,
                Value        = dictionary,
                Count        = dictionary != null ? dictionary.Count : 0
            };

            field.ItemType = field.Type.GetProperty("Item").PropertyType;

            if (dictionary != null)
            {
                foreach (object key in dictionary.Keys)
                {
                    ObjectField itemField = CreateObjectField("[" + key + "]", field.ItemType, dictionary[key], null);
                    if (itemField == null)
                    {
                        continue;
                    }
                    itemField.Parent  = field;
                    itemField.NameTag = key;
                    field.Items.Add(key, itemField);
                }
            }
            field.ItemAdded   += ItemAddedMethod;
            field.ItemRemoved += ItemRemovedMethod;

            return(field);
        }
コード例 #3
0
        /// <summary>
        /// Applies the changes mede by the user to the model.
        /// </summary>
        /// <param name="node">The changed node.</param>
        /// <param name="editor">The editor used for changing.</param>
        protected override void DoApplyChanges(TreeNodeAdv node, Control editor)
        {
            ObjectField field = node.Tag as ObjectField;

            if (field != null && field.Parent is ObjectFieldDictionary && field.NameTag is string)
            {
                ObjectFieldDictionary dictionaryField = field.Parent as ObjectFieldDictionary;
                IDictionary           dictionary      = dictionaryField.Value as IDictionary;

                if (dictionary != null)
                {
                    dictionaryField.Items.Remove(field.NameTag);
                    dictionary.Remove(field.NameTag);

                    field.NameTag = editor.Text;
                    field.Name    = "[" + editor.Text + "]";

                    dictionaryField.Items.Add(field.NameTag, field);
                    dictionary.Add(field.NameTag, field.Value);

                    editor.Text = field.Name;
                }
            }
            base.DoApplyChanges(node, editor);
        }
コード例 #4
0
        /// <summary>
        /// Gets the <see cref="ObjectField"/> which is eqivalent to the given field
        /// within this tree.
        /// </summary>
        /// <param name="field">The field to search the equivalent for.</param>
        /// <returns>The found field or null.</returns>
        public ObjectField GetEquivalentField(ObjectField field)
        {
            if (field == null || field.Parent == null)
            {
                return(TreeModel.Root);
            }
            ObjectField equivalentParentField = GetEquivalentField(field.Parent);
            ObjectField equivalentField       = null;

            ObjectFieldClass equivalentParentFieldClass = equivalentParentField as ObjectFieldClass;

            if (equivalentParentFieldClass != null)
            {
                equivalentField =
                    equivalentParentFieldClass.ChildFields.FirstOrDefault(childField => childField.Name == field.Name);
            }
            ObjectFieldList equivalentParentFieldList = equivalentParentField as ObjectFieldList;

            if (equivalentParentFieldList != null)
            {
                equivalentField = equivalentParentFieldList.Items.FirstOrDefault(item => item.Name == field.Name);
            }
            ObjectFieldDictionary equivalentParentFieldDictionary = equivalentParentField as ObjectFieldDictionary;

            if (equivalentParentFieldDictionary != null)
            {
                equivalentField = equivalentParentFieldDictionary.Items.Values.FirstOrDefault(item => item.Name == field.Name);
            }

            return(equivalentField);
        }
コード例 #5
0
 /// <summary>
 /// Gets called when an item is dropped over the treeview.
 /// </summary>
 /// <param name="sender">The sender of the event.</param>
 /// <param name="e">More information about the event.</param>
 private void trvTree_DragDrop(object sender, DragEventArgs e)
 {
     if (e.Data.GetDataPresent(typeof(TreeNodeAdv[])) && trvTree.DropPosition.Node != null)
     {
         TreeNodeAdv[] nodes  = e.Data.GetData(typeof(TreeNodeAdv[])) as TreeNodeAdv[];
         TreeNodeAdv   parent = trvTree.DropPosition.Node;
         if (nodes != null && nodes.Length == 1 && parent != null)
         {
             ObjectField draggedField = nodes[0].Tag as ObjectField;
             ObjectField destField    = parent.Tag as ObjectField;
             if (draggedField != null && destField != null)
             {
                 bool ownNode = trvTree.FindNodeByTag(draggedField) != null;
                 if (ownNode)
                 {
                     ObjectFieldList parentList = destField.Parent as ObjectFieldList;
                     if (parentList != null)
                     {
                         int index = parentList.Items.IndexOf(destField);
                         index = trvTree.DropPosition.Position == NodePosition.After ? index + 1 : index;
                         bool expanded = nodes[0].IsExpanded;
                         parentList.Move(draggedField, index);
                         trvTree.FindNodeByTag(draggedField).IsExpanded = expanded;
                     }
                 }
                 else
                 {
                     ObjectFieldDictionary parentDestDict = destField.Parent as ObjectFieldDictionary;
                     ObjectFieldList       parentDestList = destField.Parent as ObjectFieldList;
                     ObjectField           clonedField    = draggedField.Clone() as ObjectField;
                     if (clonedField != null)
                     {
                         clonedField.Parent = destField.Parent;
                         //TODO: The cloned field still wraps the uncloned value. Cloning this is not easy since
                         //      we can't use Clone() on it since it could not be implemented.
                         if (parentDestDict != null)
                         {
                             parentDestDict.Add(clonedField);
                         }
                         else if (parentDestList != null)
                         {
                             int index = parentDestList.Items.IndexOf(destField);
                             index += trvTree.DropPosition.Position == NodePosition.After ? 1 : 0;
                             parentDestList.Insert(index, clonedField);
                         }
                     }
                 }
             }
         }
     }
 }
コード例 #6
0
        /// <summary>
        /// Removes an entry from the parent <see cref="ObjectFieldCollection"/>.
        /// </summary>
        /// <param name="field">The field to remove.</param>
        private void RemoveEntry(ObjectField field)
        {
            ObjectFieldDictionary parentDictionary = field.Parent as ObjectFieldDictionary;

            if (parentDictionary != null)
            {
                parentDictionary.Remove(field);

                return;
            }

            ObjectFieldList parentList = field.Parent as ObjectFieldList;

            if (parentList != null)
            {
                parentList.Remove(field);
            }
        }
コード例 #7
0
        // ========================================================================
        // Methods

        #region === Methods

        /// <summary>
        /// Returns the children of a node at a specified path.
        /// </summary>
        /// <param name="treePath">The path.</param>
        /// <returns>The children.</returns>
        public override IEnumerable GetChildren(TreePath treePath)
        {
            ObjectField field;

            if (treePath.IsEmpty())
            {
                if (DisplayRoot == null)
                {
                    return(null);
                }
                field = DisplayRoot;
            }
            else
            {
                field = treePath.LastNode as ObjectField;
            }

            ObjectFieldClass objectFieldClass = field as ObjectFieldClass;

            if (objectFieldClass != null)
            {
                return(objectFieldClass.ChildFields);
            }
            ObjectFieldList objectFieldList = field as ObjectFieldList;

            if (objectFieldList != null)
            {
                return(objectFieldList.Items);
            }
            ObjectFieldDictionary objectFieldDictionary = field as ObjectFieldDictionary;

            if (objectFieldDictionary != null)
            {
                return(objectFieldDictionary.Items.Values);
            }
            return(null);
        }