Alguma maneira de tornar um bloco de texto WPF selecionável?

Quero tornar o texto exibido no Witty , um cliente do Twitter de código aberto, selecionável. Atualmente, ele é exibido usando um bloco de texto personalizado. Preciso usar um TextBlock porque estou trabalhando com as linhas do bloco de texto para exibir e formatar o @username e links como hiperlinks. Uma solicitação frequente é poder copiar e colar o texto. Para fazer isso, preciso tornar o TextBlock selecionável.

Tentei fazê-lo funcionar, exibindo o texto usando um TextBox somente leitura com estilo para parecer um bloco de texto, mas isso não funcionará no meu caso, porque um TextBox não possui linhas embutidas. Em outras palavras, não consigo estilizar ou formatar o texto dentro de uma TextBox individualmente, como posso com um TextBlock.

Alguma ideia?

<TextBox Background="Transparent"
         BorderThickness="0"
         Text="{Binding Text, Mode=OneWay}"
         IsReadOnly="True"
         TextWrapping="Wrap" />

Todas as respostas aqui estão apenas usando TextBoxou tentando implementar a seleção de texto manualmente, o que leva a um desempenho ruim ou a um comportamento não nativo (sinal de intermitência TextBox, nenhum suporte de teclado em implementações manuais etc.)

Depois de horas pesquisando e lendo o código fonte do WPF , descobri uma maneira de ativar a seleção de texto WPF nativa para TextBlockcontroles (ou realmente quaisquer outros controles). A maioria das funcionalidades relacionadas à seleção de texto é implementada na System.Windows.Documents.TextEditorclasse do sistema.

Para habilitar a seleção de texto para seu controle, você precisa fazer duas coisas:

1. Ligue TextEditor.RegisterCommandHandlers()uma vez para registrar os manipuladores de eventos da classe

2. Crie uma instância de TextEditorpara cada instância da sua classe e passe a instância subjacente da sua System.Windows.Documents.ITextContainerpara ela

Também é necessário que a Focusablepropriedade do seu controle esteja definida True.

É isso! Parece fácil, mas infelizmente a TextEditorclasse está marcada como interna. Então eu tive que escrever um invólucro de reflexão:

class TextEditorWrapper
{
    private static readonly Type TextEditorType = Type.GetType("System.Windows.Documents.TextEditor, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
    private static readonly PropertyInfo IsReadOnlyProp = TextEditorType.GetProperty("IsReadOnly", BindingFlags.Instance | BindingFlags.NonPublic);
    private static readonly PropertyInfo TextViewProp = TextEditorType.GetProperty("TextView", BindingFlags.Instance | BindingFlags.NonPublic);
    private static readonly MethodInfo RegisterMethod = TextEditorType.GetMethod("RegisterCommandHandlers", 
        BindingFlags.Static | BindingFlags.NonPublic, null, new[] { typeof(Type), typeof(bool), typeof(bool), typeof(bool) }, null);

    private static readonly Type TextContainerType = Type.GetType("System.Windows.Documents.ITextContainer, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
    private static readonly PropertyInfo TextContainerTextViewProp = TextContainerType.GetProperty("TextView");

    private static readonly PropertyInfo TextContainerProp = typeof(TextBlock).GetProperty("TextContainer", BindingFlags.Instance | BindingFlags.NonPublic);

    public static void RegisterCommandHandlers(Type controlType, bool acceptsRichContent, bool readOnly, bool registerEventListeners)
    {
        RegisterMethod.Invoke(null, new object[] { controlType, acceptsRichContent, readOnly, registerEventListeners });
    }

    public static TextEditorWrapper CreateFor(TextBlock tb)
    {
        var textContainer = TextContainerProp.GetValue(tb);

        var editor = new TextEditorWrapper(textContainer, tb, false);
        IsReadOnlyProp.SetValue(editor._editor, true);
        TextViewProp.SetValue(editor._editor, TextContainerTextViewProp.GetValue(textContainer));

        return editor;
    }

    private readonly object _editor;

    public TextEditorWrapper(object textContainer, FrameworkElement uiScope, bool isUndoEnabled)
    {
        _editor = Activator.CreateInstance(TextEditorType, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.CreateInstance, 
            null, new[] { textContainer, uiScope, isUndoEnabled }, null);
    }
}

Eu também criei um SelectableTextBlockderivado TextBlockque executa as etapas mencionadas acima:

public class SelectableTextBlock : TextBlock
{
    static SelectableTextBlock()
    {
        FocusableProperty.OverrideMetadata(typeof(SelectableTextBlock), new FrameworkPropertyMetadata(true));
        TextEditorWrapper.RegisterCommandHandlers(typeof(SelectableTextBlock), true, true, true);

        // remove the focus rectangle around the control
        FocusVisualStyleProperty.OverrideMetadata(typeof(SelectableTextBlock), new FrameworkPropertyMetadata((object)null));
    }

    private readonly TextEditorWrapper _editor;

    public SelectableTextBlock()
    {
        _editor = TextEditorWrapper.CreateFor(this);
    }
}

Outra opção seria criar uma propriedade anexada para TextBlockativar a seleção de texto sob demanda. Nesse caso, para desativar a seleção novamente, é necessário desanexar a TextEditorusando o equivalente de reflexão deste código:

_editor.TextContainer.TextView = null;
_editor.OnDetach();
_editor = null;

Não consegui encontrar nenhum exemplo de realmente responder à pergunta. Todas as respostas usaram uma caixa de texto ou RichTextbox. Eu precisava de uma solução que me permitisse usar um TextBlock, e essa é a solução que eu criei.

Acredito que a maneira correta de fazer isso é estender a classe TextBlock. Este é o código que eu usei para estender a classe TextBlock para permitir que eu selecione o texto e copie-o para a área de transferência. "sdo" é a referência de espaço para nome que usei no WPF.

WPF usando classe estendida:

xmlns:sdo="clr-namespace:iFaceCaseMain"

<sdo:TextBlockMoo x:Name="txtResults" Background="Black" Margin="5,5,5,5" 
      Foreground="GreenYellow" FontSize="14" FontFamily="Courier New"></TextBlockMoo>

Código Atrás para Classe Estendida:

public partial class TextBlockMoo : TextBlock 
{
    TextPointer StartSelectPosition;
    TextPointer EndSelectPosition;
    public String SelectedText = "";

    public delegate void TextSelectedHandler(string SelectedText);
    public event TextSelectedHandler TextSelected;

    protected override void OnMouseDown(MouseButtonEventArgs e)
    {
        base.OnMouseDown(e);
        Point mouseDownPoint = e.GetPosition(this);
        StartSelectPosition = this.GetPositionFromPoint(mouseDownPoint, true);            
    }

    protected override void OnMouseUp(MouseButtonEventArgs e)
    {
        base.OnMouseUp(e);
        Point mouseUpPoint = e.GetPosition(this);
        EndSelectPosition = this.GetPositionFromPoint(mouseUpPoint, true);

        TextRange otr = new TextRange(this.ContentStart, this.ContentEnd);
        otr.ApplyPropertyValue(TextElement.ForegroundProperty, new SolidColorBrush(Colors.GreenYellow));

        TextRange ntr = new TextRange(StartSelectPosition, EndSelectPosition);
        ntr.ApplyPropertyValue(TextElement.ForegroundProperty, new SolidColorBrush(Colors.White));

        SelectedText = ntr.Text;
        if (!(TextSelected == null))
        {
            TextSelected(SelectedText);
        }
    }
}

Exemplo de código da janela:

    public ucExample(IInstanceHost host, ref String WindowTitle, String ApplicationID, String Parameters)
    {
        InitializeComponent();
        /*Used to add selected text to clipboard*/
        this.txtResults.TextSelected += txtResults_TextSelected;
    }

    void txtResults_TextSelected(string SelectedText)
    {
        Clipboard.SetText(SelectedText);
    }

Aplique esse estilo ao seu TextBox e pronto (inspirado neste artigo ):

<Style x:Key="SelectableTextBlockLikeStyle" TargetType="TextBox" BasedOn="{StaticResource {x:Type TextBox}}">
    <Setter Property="IsReadOnly" Value="True"/>
    <Setter Property="IsTabStop" Value="False"/>
    <Setter Property="BorderThickness" Value="0"/>
    <Setter Property="Background" Value="Transparent"/>
    <Setter Property="Padding" Value="-2,0,0,0"/>
    <!-- The Padding -2,0,0,0 is required because the TextBox
        seems to have an inherent "Padding" of about 2 pixels.
        Without the Padding property,
        the text seems to be 2 pixels to the left
        compared to a TextBlock
    -->
    <Style.Triggers>
        <MultiTrigger>
            <MultiTrigger.Conditions>
                <Condition Property="IsMouseOver" Value="False" />
                <Condition Property="IsFocused" Value="False" />
            </MultiTrigger.Conditions>
            <Setter Property="Template">
                <Setter.Value>
                <ControlTemplate TargetType="{x:Type TextBox}">
                    <TextBlock Text="{TemplateBinding Text}" 
                             FontSize="{TemplateBinding FontSize}"
                             FontStyle="{TemplateBinding FontStyle}"
                             FontFamily="{TemplateBinding FontFamily}"
                             FontWeight="{TemplateBinding FontWeight}"
                             TextWrapping="{TemplateBinding TextWrapping}"
                             Foreground="{DynamicResource NormalText}"
                             Padding="0,0,0,0"
                                       />
                </ControlTemplate>
                </Setter.Value>
            </Setter>
        </MultiTrigger>
    </Style.Triggers>
</Style>

Crie ControlTemplate para o TextBlock e coloque um TextBox dentro com o conjunto de propriedades readonly. Ou basta usar o TextBox e torná-lo somente leitura, então você pode alterar o TextBox.Style para parecer com o TextBlock.

Não tenho certeza se você pode tornar um TextBlock selecionável, mas outra opção seria usar um RichTextBox - é como um TextBox, como você sugeriu, mas suporta a formatação desejada.

De acordo com o Windows Dev Center :

Propriedade TextBlock.IsTextSelectionEnabled

[Atualizado para aplicativos UWP no Windows 10. Para artigos do Windows 8.x, consulte o arquivo ]

Obtém ou define um valor que indica se a seleção de texto está ativada no TextBlock , por meio da ação do usuário ou da chamada da API relacionada à seleção.

Embora a pergunta diga 'Selecionável', acredito que os resultados intencionais são levar o texto para a área de transferência. Isso pode ser feito de maneira fácil e elegante adicionando um Menu de Contexto e um item de menu chamado copy que coloca o valor da propriedade Textblock Text na área de transferência. Apenas uma idéia de qualquer maneira.

O TextBlock não possui um modelo. Portanto, para conseguir isso, precisamos usar um TextBox cujo estilo foi alterado para se comportar como um bloco de texto.

<Style x:Key="TextBlockUsingTextBoxStyle" BasedOn="{x:Null}" TargetType="{x:Type TextBox}">
    <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}"/>
    <Setter Property="Background" Value="Transparent"/>
    <Setter Property="BorderBrush" Value="{StaticResource TextBoxBorder}"/>
    <Setter Property="BorderThickness" Value="0"/>
    <Setter Property="Padding" Value="1"/>
    <Setter Property="AllowDrop" Value="true"/>
    <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
    <Setter Property="ScrollViewer.PanningMode" Value="VerticalFirst"/>
    <Setter Property="Stylus.IsFlicksEnabled" Value="False"/>
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="{x:Type TextBox}">
                <TextBox BorderThickness="{TemplateBinding BorderThickness}" IsReadOnly="True" Text="{TemplateBinding Text}" Background="{x:Null}" BorderBrush="{x:Null}" />
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>

Há uma solução alternativa que pode ser adaptável ao RichTextBox excluído nesta postagem do blog - ele usou um gatilho para trocar o modelo de controle quando o uso passa o mouse sobre o controle - deve ajudar no desempenho

new TextBox
{
   Text = text,
   TextAlignment = TextAlignment.Center,
   TextWrapping = TextWrapping.Wrap,
   IsReadOnly = true,
   Background = Brushes.Transparent,
   BorderThickness = new Thickness()
         {
             Top = 0,
             Bottom = 0,
             Left = 0,
             Right = 0
         }
};

Adicionando à resposta de @ torvin e como @Dave Huang mencionado nos comentários, se você tiver TextTrimming="CharacterEllipsis"ativado o aplicativo trava ao passar o mouse sobre as reticências.

Tentei outras opções mencionadas no tópico sobre o uso de um TextBox, mas ele realmente não parece ser a solução, pois não mostra as 'reticências' e também se o texto é muito longo para caber no contêiner, selecionando o conteúdo de a caixa de texto 'rola' internamente, o que não é um comportamento do TextBlock.

Eu acho que a melhor solução é a resposta de @ torvin, mas tem uma falha grave ao passar o mouse sobre as reticências.

Eu sei que não é bonito, mas assinar / cancelar a assinatura internamente de exceções não tratadas e manipular a exceção foi a única maneira que encontrei para resolver esse problema. Compartilhe se alguém tiver uma solução melhor :)

public class SelectableTextBlock : TextBlock
{
    static SelectableTextBlock()
    {
        FocusableProperty.OverrideMetadata(typeof(SelectableTextBlock), new FrameworkPropertyMetadata(true));
        TextEditorWrapper.RegisterCommandHandlers(typeof(SelectableTextBlock), true, true, true);

        // remove the focus rectangle around the control
        FocusVisualStyleProperty.OverrideMetadata(typeof(SelectableTextBlock), new FrameworkPropertyMetadata((object)null));
    }

    private readonly TextEditorWrapper _editor;

    public SelectableTextBlock()
    {
        _editor = TextEditorWrapper.CreateFor(this);

        this.Loaded += (sender, args) => {
            this.Dispatcher.UnhandledException -= Dispatcher_UnhandledException;
            this.Dispatcher.UnhandledException += Dispatcher_UnhandledException;
        };
        this.Unloaded += (sender, args) => {
            this.Dispatcher.UnhandledException -= Dispatcher_UnhandledException;
        };
    }

    private void Dispatcher_UnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
    {
        if (!string.IsNullOrEmpty(e?.Exception?.StackTrace))
        {
            if (e.Exception.StackTrace.Contains("System.Windows.Controls.TextBlock.GetTextPositionFromDistance"))
            {
                e.Handled = true;
            }
        }
    }
}

Eu implementei o SelectableTextBlock na minha biblioteca de controles de código-fonte aberto. Você pode usá-lo assim:

<jc:SelectableTextBlock Text="Some text" />

public MainPage()
{
    this.InitializeComponent();
    ...
    ...
    ...
    //Make Start result text copiable
    TextBlockStatusStart.IsTextSelectionEnabled = true;
}

Really nice and easy solution, exactly what I wanted !

Trago algumas pequenas modificações

public class TextBlockMoo : TextBlock 
{
    public String SelectedText = "";

    public delegate void TextSelectedHandler(string SelectedText);
    public event TextSelectedHandler OnTextSelected;
    protected void RaiseEvent()
    {
        if (OnTextSelected != null){OnTextSelected(SelectedText);}
    }

    TextPointer StartSelectPosition;
    TextPointer EndSelectPosition;
    Brush _saveForeGroundBrush;
    Brush _saveBackGroundBrush;

    TextRange _ntr = null;

    protected override void OnMouseDown(MouseButtonEventArgs e)
    {
        base.OnMouseDown(e);

        if (_ntr!=null) {
            _ntr.ApplyPropertyValue(TextElement.ForegroundProperty, _saveForeGroundBrush);
            _ntr.ApplyPropertyValue(TextElement.BackgroundProperty, _saveBackGroundBrush);
        }

        Point mouseDownPoint = e.GetPosition(this);
        StartSelectPosition = this.GetPositionFromPoint(mouseDownPoint, true);            
    }

    protected override void OnMouseUp(MouseButtonEventArgs e)
    {
        base.OnMouseUp(e);
        Point mouseUpPoint = e.GetPosition(this);
        EndSelectPosition = this.GetPositionFromPoint(mouseUpPoint, true);

        _ntr = new TextRange(StartSelectPosition, EndSelectPosition);

        // keep saved
        _saveForeGroundBrush = (Brush)_ntr.GetPropertyValue(TextElement.ForegroundProperty);
        _saveBackGroundBrush = (Brush)_ntr.GetPropertyValue(TextElement.BackgroundProperty);
        // change style
        _ntr.ApplyPropertyValue(TextElement.BackgroundProperty, new SolidColorBrush(Colors.Yellow));
        _ntr.ApplyPropertyValue(TextElement.ForegroundProperty, new SolidColorBrush(Colors.DarkBlue));

        SelectedText = _ntr.Text;
    }
}