private void ProcessElementRecuresively(DocumentModelProcessContext context, IElement element, IElement parent)
        {
            if (!context.ElementPointers.ContainsKey(element))
            {
                var documentObject = CreateDocumentObject(context, element);
                if (parent != null)
                {
                    if (!context.ElementPointers.ContainsKey(parent))
                    {
                        context.ElementPointers[parent] = CreateDocumentObject(context, parent);
                    }

                    var parentDocumentObject = context.ElementPointers[parent];
                    documentObject.Parent = parentDocumentObject;
                    parentDocumentObject.Children.Add(documentObject);
                }
            }

            if (element is IComponent component)
            {
                // Continue adding elements to tree by switching to component's tree
                foreach (var child in component.ElementTree.Children)
                {
                    ProcessElementRecuresively(context, child, element);
                }

                if (component.Children.Any())
                {
#warning Fix here! Temporarily use only single placeholder!
                    var placeholder = component.ElementTree.PlaceholderElements.FirstOrDefault();

                    if (placeholder == null)
                    {
                        // Add children elements to component's placeholder
                        foreach (var child in component.Children)
                        {
                            ProcessElementRecuresively(context, child, element);
                        }
                    }
                    else
                    {
                        foreach (var child in component.Children)
                        {
                            ProcessElementRecuresively(context, child, placeholder);
                        }
                    }
                }
            }
            else
            {
                foreach (var child in element.Children)
                {
                    ProcessElementRecuresively(context, child, element);
                }
            }
        }
        /// <summary>
        /// Calculates the structure of the document model.
        /// </summary>
        /// <param name="documentModel">Document model to recalculate</param>
        public void Restructure(IDocumentModelTree documentModel)
        {
            var context = new DocumentModelProcessContext()
            {
                DocumentModel   = (DocumentModelTree)documentModel,
                ElementPointers = new Dictionary <IElement, IDocumentObject>()
            };

            foreach (var element in ElementTree.NavigateAllElementsRecursively(context.DocumentModel.OwnerComponent))
            {
            }
            ProcessElementRecuresively(context, context.DocumentModel.OwnerComponent, null);
            context.DocumentModel.RootDocumentObject = context.ElementPointers[context.DocumentModel.OwnerComponent];
        }
        private DocumentObject CreateDocumentObject(DocumentModelProcessContext context, IElement element)
        {
            var documentObject = new DocumentObject()
            {
                OwnerDocumentModel = context.DocumentModel,
                Element            = element
            };

            if (element.Parent != null)
            {
                documentObject.Parent = context.ElementPointers[element.Parent];
            }
            context.ElementPointers[element] = documentObject;
            return(documentObject);
        }