public override DataItem LoadData(XElement element, UndoRedoManager undoRedo)
        {
            var item = new GraphCollectionItem(this, undoRedo);

            item.X       = TryParseFloat(element, MetaNS + "X");
            item.Y       = TryParseFloat(element, MetaNS + "Y");
            item.GUID    = element.Attribute("GUID")?.Value?.ToString();
            item.Comment = element.Attribute(MetaNS + "Comment")?.Value?.ToString();

            foreach (var el in element.Elements())
            {
                var prev = el.PreviousNode as XComment;
                if (prev != null)
                {
                    var comment = new CommentDefinition().LoadData(prev, undoRedo);
                    item.Children.Add(comment);
                }

                var cdef  = ChildDefinitions.FirstOrDefault(e => e.Name == el.Name);
                var child = cdef.LoadData(el, undoRedo);
                item.Children.Add(child);

                if (item.Children.Count == MaxCount)
                {
                    break;
                }
            }

            if (element.LastNode is XComment)
            {
                var comment = new CommentDefinition().LoadData(element.LastNode as XComment, undoRedo);
                item.Children.Add(comment);
            }

            foreach (var att in Attributes)
            {
                var      el      = element.Attribute(att.Name);
                DataItem attItem = null;

                if (el != null)
                {
                    attItem = att.LoadData(new XElement(el.Name, el.Value.ToString()), undoRedo);
                }
                else
                {
                    attItem = att.CreateData(undoRedo);
                }
                item.Attributes.Add(attItem);
            }

            return(item);
        }
        public override DataItem CreateData(UndoRedoManager undoRedo)
        {
            var item = new GraphCollectionItem(this, undoRedo);

            if (ChildDefinitions.Count == 1)
            {
                for (int i = 0; i < MinCount; i++)
                {
                    var child = ChildDefinitions[0].CreateData(undoRedo);
                    item.Children.Add(child);
                }
            }

            foreach (var att in Attributes)
            {
                var attItem = att.CreateData(undoRedo);
                item.Attributes.Add(attItem);
            }

            return(item);
        }
Exemplo n.º 3
0
        //-----------------------------------------------------------------------
        protected override void OnDrop(DragEventArgs e)
        {
            if (e.Data.GetDataPresent("GraphNodeData") && (Data.Parent is GraphCollectionItem || Data.Parent.Parent is GraphCollectionItem))
            {
                DataItem item        = e.Data.GetData("GraphNodeData") as DataItem;
                DataItem droppedItem = Data.Parent is CollectionChildItem ? Data.Parent as DataItem : Data;

                if (item == droppedItem)
                {
                    return;
                }

                GraphCollectionItem collection = droppedItem.Parent as GraphCollectionItem;

                bool isValid = false;

                if (item is CommentItem)
                {
                    isValid = true;
                }
                else
                {
                    var wrapped = (item as CollectionChildItem).WrappedItem;

                    var droppedDef = wrapped.Definition;
                    if (droppedDef is ReferenceDefinition)
                    {
                        droppedDef = (wrapped as ReferenceItem).WrappedItem?.Definition ?? wrapped.Definition;
                    }
                    else if (droppedDef is GraphReferenceDefinition)
                    {
                        droppedDef = (wrapped as GraphReferenceItem).WrappedItem?.Definition ?? wrapped.Definition;
                    }

                    var cdef = (collection as GraphCollectionItem).CDef;

                    foreach (var def in cdef.ChildDefinitions)
                    {
                        var wrappeddef = def.WrappedDefinition;
                        if (wrappeddef == droppedDef)
                        {
                            isValid = true;
                            break;
                        }

                        if (wrappeddef is ReferenceDefinition)
                        {
                            if ((wrappeddef as ReferenceDefinition).Definitions.Values.Contains(droppedDef))
                            {
                                isValid = true;
                                break;
                            }
                        }
                        else if (wrappeddef is GraphReferenceDefinition)
                        {
                            if ((wrappeddef as GraphReferenceDefinition).Definitions.Values.Contains(droppedDef))
                            {
                                isValid = true;
                                break;
                            }
                        }
                    }
                }

                if (isValid)
                {
                    if (droppedItem.Parent != item.Parent)
                    {
                        int srcIndex = item.Parent.Children.IndexOf(item);
                        int dstIndex = droppedItem.Parent.Children.IndexOf(droppedItem);

                        if (adorner.InsertionState == InsertionAdorner.InsertionStateEnum.After)
                        {
                            dstIndex = Math.Min(dstIndex + 1, collection.Children.Count - 1);
                        }

                        var srcCollection = item.Parent;
                        var dstCollection = droppedItem.Parent;

                        item.UndoRedo.ApplyDoUndo(() =>
                        {
                            srcCollection.Children.RemoveAt(srcIndex);
                            dstCollection.Children.Insert(dstIndex, item);
                        }, () =>
                        {
                            dstCollection.Children.RemoveAt(dstIndex);
                            srcCollection.Children.Insert(srcIndex, item);
                        }, "Move item");
                    }
                    else
                    {
                        int srcIndex = collection.Children.IndexOf(item);
                        int dstIndex = collection.Children.IndexOf(droppedItem);

                        if (srcIndex < dstIndex)
                        {
                            dstIndex--;
                        }

                        if (adorner.InsertionState == InsertionAdorner.InsertionStateEnum.After)
                        {
                            dstIndex = Math.Min(dstIndex + 1, collection.Children.Count - 1);
                        }

                        if (srcIndex != dstIndex)
                        {
                            (collection as ICollectionItem).MoveItem(srcIndex, dstIndex);
                        }
                    }
                }
            }

            if (adorner != null)
            {
                adorner.Detach();
                adorner = null;
            }
        }