8

我将 FlowDocument 与 BlockUIContainer 和 InlineUIContainer 元素一起使用，这些元素包含（或作为基类）一些自定义块 - SVG、数学公式等。因此，使用 Selection.Load(stream, DataFormats.XamlPackage) 将不起作用，因为序列化将删除 * UIContainers，除非 Child 属性是 Microsoft 参考源中可用的图像：

private static void WriteStartXamlElement(...)
{
    ...
    if ((inlineUIContainer == null || !(inlineUIContainer.Child is Image)) &&
                (blockUIContainer == null || !(blockUIContainer.Child is Image)))
    {
        ...
        elementTypeStandardized = TextSchema.GetStandardElementType(elementType, /*reduceElement:*/true);
    }
    ...
}

在这种情况下，唯一的选择是使用完美工作的 XamlWriter.Save 和 XamlReader.Load，序列化和反序列化 FlowDocument 的所有必需属性和对象，但必须手动实现 Copy+Paste 作为 Copy+ 的默认实现粘贴使用 Selection.Load/Save。

复制/粘贴非常重要，因为它还用于处理在 RichTextBox 控件中或之间拖动元素 - 这是无需自定义拖动代码即可操作对象的唯一方法。

这就是为什么我希望使用 FlowDocument 序列化来实现复制/粘贴，但不幸的是它存在一些问题：

  1. 在当前解决方案中，需要对整个 FlowDocument 对象进行序列化/反序列化。就性能而言，这应该不是问题，但我需要存储需要从中粘贴哪些选择范围的信息（CustomRichTextBoxTag 类）。

  2. 显然，对象不能从一个文档中删除并添加到另一个文档（我最近发现的一个死胡同）：“InlineCollection”元素不能插入到树中，因为它已经是树的子节点。

    [TextElementCollection.cs]
public void InsertAfter(TextElementType previousSibling, TextElementType newItem)
{
    ...
    if (previousSibling.Parent != this.Parent)
        throw new InvalidOperationException(System.Windows.SR.Get("TextElementCollection_PreviousSiblingDoesNotBelongToThisCollection", new object[1]
        {
            (object) previousSibling.GetType().Name
        }));
    ...
}

    我考虑在所有需要移动到另一个文档的元素中使用反射来设置 FrameworkContentElement._parent，但这是最后的手段 hackish 和肮脏的解决方案：

  3. 从理论上讲，我只能复制所需的对象：（可选）在选择开始时使用文本部分运行，中间的所有段落和内联以及（可能）在最后部分运行，将这些封装在自定义类中并使用序列化/反序列化XamlReader/XamlWriter。

  4. 另一个我没有想到的解决方案。

这是自定义的 RichTextBox 控件实现，其中包含部分工作的自定义复制/粘贴代码：

using System.IO;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Markup;

namespace FlowMathTest
{
    public class CustomRichTextBoxTag: DependencyObject
    {
        public static readonly DependencyProperty SelectionStartProperty = DependencyProperty.Register(
            "SelectionStart",
            typeof(int),
            typeof(CustomRichTextBoxTag));

        public int SelectionStart
        {
            get { return (int)GetValue(SelectionStartProperty); }
            set { SetValue(SelectionStartProperty, value); }
        }

        public static readonly DependencyProperty SelectionEndProperty = DependencyProperty.Register(
            "SelectionEnd",
            typeof(int),
            typeof(CustomRichTextBoxTag));

        public int SelectionEnd
        {
            get { return (int)GetValue(SelectionEndProperty); }
            set { SetValue(SelectionEndProperty, value); }
        }
    }

    public class CustomRichTextBox: RichTextBox
    {
        public CustomRichTextBox()
        {
            DataObject.AddCopyingHandler(this, OnCopy);
            DataObject.AddPastingHandler(this, OnPaste);
        }

        protected override void OnSelectionChanged(RoutedEventArgs e)
        {
            base.OnSelectionChanged(e);
            var tag = Document.Tag as CustomRichTextBoxTag;
            if(tag == null)
            {
                tag = new CustomRichTextBoxTag();
                Document.Tag = tag;
            }
            tag.SelectionStart = Document.ContentStart.GetOffsetToPosition(Selection.Start);
            tag.SelectionEnd = Document.ContentStart.GetOffsetToPosition(Selection.End);
        }

        private void OnCopy(object sender, DataObjectCopyingEventArgs e)
        {
            if(e.DataObject != null)
            {
                e.Handled = true;
                var ms = new MemoryStream();
                XamlWriter.Save(Document, ms);
                e.DataObject.SetData(DataFormats.Xaml, ms);
            }
        }

        private void OnPaste(object sender, DataObjectPastingEventArgs e)
        {
            var xamlData = e.DataObject.GetData(DataFormats.Xaml) as MemoryStream;
            if(xamlData != null)
            {
                xamlData.Position = 0;
                var fd = XamlReader.Load(xamlData) as FlowDocument;
                if(fd != null)
                {
                    var tag = fd.Tag as CustomRichTextBoxTag;
                    if(tag != null)
                    {
                        InsertAt(Document, Selection.Start, Selection.End, fd, fd.ContentStart.GetPositionAtOffset(tag.SelectionStart), fd.ContentStart.GetPositionAtOffset(tag.SelectionEnd));
                        e.Handled = true;
                    }
                }
            }
        }

        public static void InsertAt(FlowDocument destDocument, TextPointer destStart, TextPointer destEnd, FlowDocument sourceDocument, TextPointer sourceStart, TextPointer sourceEnd)
        {
            var destRange = new TextRange(destStart, destEnd);
            destRange.Text = string.Empty;

            // insert partial text of the first run in the selection
            if(sourceStart.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.Text)
            {
                var sourceRange = new TextRange(sourceStart, sourceStart.GetNextContextPosition(LogicalDirection.Forward));
                destStart.InsertTextInRun(sourceRange.Text);
                sourceStart = sourceStart.GetNextContextPosition(LogicalDirection.Forward);
                destStart = destStart.GetNextContextPosition(LogicalDirection.Forward);
            }

            var field = typeof(FrameworkContentElement).GetField("_parent", BindingFlags.NonPublic | BindingFlags.Instance);
            while(sourceStart != null && sourceStart.CompareTo(sourceEnd) <= 0 && sourceStart.Paragraph != null)
            {
                var sourceInline = sourceStart.Parent as Inline;
                if(sourceInline != null)
                {
                    sourceStart.Paragraph.Inlines.Remove(sourceInline);
                    if(destStart.Parent is Inline)
                    {
                        field.SetValue(sourceInline, null);
                        destStart.Paragraph.Inlines.InsertAfter(destStart.Parent as Inline, sourceInline);
                    }
                    else
                    {
                        var p = new Paragraph();
                        destDocument.Blocks.InsertAfter(destStart.Paragraph, p);
                        p.Inlines.Add(sourceInline);
                    }
                    sourceStart = sourceStart.GetNextContextPosition(LogicalDirection.Forward);
                }
                else
                {
                    var sourceBlock = sourceStart.Parent as Block;
                    field.SetValue(sourceBlock, null);
                    destDocument.Blocks.InsertAfter(destStart.Paragraph, sourceBlock);
                    sourceStart = sourceStart.GetNextContextPosition(LogicalDirection.Forward);
                }
            }
        }
    }
}

还有一个问题 - 是否存在使用 XamlReader 和 XamlWriter 为 FlowDocument 自定义复制+粘贴代码的现有解决方案？如何修复上面的代码，使其不会抱怨不同的 FlowDocument 对象或解决此限制？

编辑：作为一个实验，我实现了 2)，以便可以将对象从一个 FlowDocument 移动到另一个。上面的代码已更新 - 所有对“字段”变量的引用。

4

2 回答 2

4

看来赏金期快到期了，我突破了如何实现上面的问题，所以在这里分享一下。

首先，TextRange.Save 有一个“preserveTextElements”参数，可用于序列化 InlineUIContainer 和 BlockUIContainer 元素。此外，这两个控件都不是密封的，因此可以用作自定义 TextElement 实现的基类。

考虑到上述情况：

  1. 我创建了一个继承自 InlineUIContainer 的 InlineMedia 元素，该元素使用 XamlReader 和 XamlWriter 将其 Child“手动”序列化为“ChildSource”依赖属性，并从默认序列化程序中隐藏原始“Child”

  2. 我将 CustomRichTextBox 的上述实现更改为使用 range.Save(ms, DataFormats.Xaml, true) 复制选择。

正如您所注意到的，不需要特殊的粘贴处理，因为在剪贴板中交换原始 Xaml 后，Xaml 可以很好地反序列化，这意味着从所有 CustomRichtextBox 控件拖动工作作为副本，并且粘贴甚至可以工作到正常的 RichTextBox。

唯一的限制是，对于所有 InlineMedia 控件，ChildSource 属性需要在序列化整个文档之前通过序列化它的 Child 来更新，我发现无法自动执行此操作（在保存元素之前挂钩到 TextRange.Save）。

我可以忍受，但是没有这个问题的更好的解决方案仍然会得到赏金！

InlineMedia 元素代码：

public class InlineMedia: InlineUIContainer
{
    public InlineMedia()
    {
    }

    public InlineMedia(UIElement childUIElement) : base(childUIElement)
    {
        UpdateChildSource();
    }

    public InlineMedia(UIElement childUIElement, TextPointer insertPosition)
        : base(childUIElement, insertPosition)
    {
        UpdateChildSource();
    }

    public static readonly DependencyProperty ChildSourceProperty = DependencyProperty.Register
    (
        "ChildSource",
        typeof(string),
        typeof(InlineMedia),
        new FrameworkPropertyMetadata(null, OnChildSourceChanged));

    public string ChildSource
    {
        get
        {
            return (string)GetValue(ChildSourceProperty);
        }
        set
        {
            SetValue(ChildSourceProperty, value);
        }
    }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public new UIElement Child
    {
        get
        {
            return base.Child;
        }
        set
        {
            base.Child = value;
            UpdateChildSource();
        }
    }

    public void UpdateChildSource()
    {
        IsInternalChildSourceChange = true;
        try
        {
            ChildSource = Save();
        }
        finally
        {
            IsInternalChildSourceChange = false;
        }
    }


    public string Save()
    {
        if(Child == null)
        {
            return null;
        }

        using(var stream = new MemoryStream())
        {
            XamlWriter.Save(Child, stream);
            stream.Position = 0;
            using(var reader = new StreamReader(stream, Encoding.UTF8))
            {
                return reader.ReadToEnd();
            }
        }
    }

    public void Load(string sourceData)
    {
        if(string.IsNullOrEmpty(sourceData))
        {
            base.Child = null;
        }
        else
        {
            using(var stream = new MemoryStream(Encoding.UTF8.GetBytes(sourceData)))
            {
                var child = XamlReader.Load(stream);
                base.Child = (UIElement)child;
            }
        }
    }

    private static void OnChildSourceChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
    {
        var img = (InlineMedia) sender;
        if(img != null && !img.IsInternalChildSourceChange)
        {
            img.Load((string)e.NewValue);
        }
    }

    protected bool IsInternalChildSourceChange { get; private set; }
}

CustomRichTextBox 控件代码：

public class CustomRichTextBox: RichTextBox
{
    public CustomRichTextBox()
    {
        DataObject.AddCopyingHandler(this, OnCopy);
    }

    private void OnCopy(object sender, DataObjectCopyingEventArgs e)
    {
        if(e.DataObject != null)
        {
            UpdateDocument();
            var range = new TextRange(Selection.Start, Selection.End);
            using(var ms = new MemoryStream())
            {
                range.Save(ms, DataFormats.Xaml, true);
                ms.Position = 0;
                using(var reader = new StreamReader(ms, Encoding.UTF8))
                {
                    var xaml = reader.ReadToEnd();
                    e.DataObject.SetData(DataFormats.Xaml, xaml);
                }
            }
            e.Handled = true;
        }
    }

    public void UpdateDocument()
    {
        ObjectHelper.ExecuteRecursive<InlineMedia>(Document, i => i.UpdateChildSource(), FlowDocumentVisitors);
    }

    private static readonly Func<object, object>[] FlowDocumentVisitors =
    {
        x => (x is FlowDocument) ? ((FlowDocument) x).Blocks : null,
        x => (x is Section) ? ((Section) x).Blocks : null,
        x => (x is BlockUIContainer) ? ((BlockUIContainer) x).Child : null,
        x => (x is InlineUIContainer) ? ((InlineUIContainer) x).Child : null,
        x => (x is Span) ? ((Span) x).Inlines : null,
        x => (x is Paragraph) ? ((Paragraph) x).Inlines : null,
        x => (x is Table) ? ((Table) x).RowGroups : null,
        x => (x is Table) ? ((Table) x).Columns : null,
        x => (x is Table) ? ((Table) x).RowGroups.SelectMany(rg => rg.Rows) : null,
        x => (x is Table) ? ((Table) x).RowGroups.SelectMany(rg => rg.Rows).SelectMany(r => r.Cells) : null,
        x => (x is TableCell) ? ((TableCell) x).Blocks : null,
        x => (x is TableCell) ? ((TableCell) x).BorderBrush : null,
        x => (x is List) ? ((List) x).ListItems : null,
        x => (x is ListItem) ? ((ListItem) x).Blocks : null
    };
}

最后是 ObjectHelper 类 - 访客助手：

public static class ObjectHelper
{
    public static void ExecuteRecursive(object item, Action<object> execute, params Func<object, object>[] childSelectors)
    {
        ExecuteRecursive<object, object>(item, null, (c, i) => execute(i), childSelectors);
    }

    public static void ExecuteRecursive<TObject>(object item, Action<TObject> execute, params Func<object, object>[] childSelectors)
    {
        ExecuteRecursive<object, TObject>(item, null, (c, i) => execute(i), childSelectors);
    }

    public static void ExecuteRecursive<TContext, TObject>(object item, TContext context, Action<TContext, TObject> execute, params Func<object, object>[] childSelectors)
    {
        ExecuteRecursive(item, context, (c, i) =>
        {
            if(i is TObject)
            {
                execute(c, (TObject)i);
            }
        }, childSelectors);
    }

    public static void ExecuteRecursive<TContext>(object item, TContext context, Action<TContext, object> execute, params Func<object, object>[] childSelectors)
    {
        execute(context, item);
        if(item is IEnumerable)
        {
            foreach(var subItem in item as IEnumerable)
            {
                ExecuteRecursive(subItem, context, execute, childSelectors);
            }
        }
        if(childSelectors != null)
        {
            foreach(var subItem in childSelectors.Select(x => x(item)).Where(x => x != null))
            {
                ExecuteRecursive(subItem, context, execute, childSelectors);
            }
        }
    }
}
于 2014-09-15T10:55:30.757 回答
1

1.在当前解决方案中，需要对整个 FlowDocument 对象进行序列化/反序列化。就性能而言，这应该不是问题，但我需要存储需要从中粘贴哪些选择范围的信息（CustomRichTextBoxTag 类）。

这听起来像是根据您确定的预期行为使用附加属性的机会。我将附加属性理解为向元素添加附加行为的一种方式。当您注册附加属性时，您可以添加一个事件处理程序，用于该属性值更改时。为了利用这一点，我会将此附加属性连接到 DataTrigger 以更新复制/粘贴操作的选择范围值。

2. 显然对象不能从一个文档中删除并添加到另一个文档中（我最近发现的一个死胡同）：“InlineCollection”元素不能插入到树中，因为它已经是树的子级。

您可以通过以编程方式构建元素并以编程方式删除元素来解决此问题。归根结底，您主要处理的是 ItemsControl 或 ContentControl。在这种情况下，您使用 ItemsControl（即文档）。因此，只需以编程方式从您的 ItemsControl（文档）中添加和删除子元素。

于 2014-09-14T11:41:11.580 回答