Jest jakiś sposób na wybranie bloku tekstowego WPF?

Chcę, aby tekst wyświetlany w Witty , kliencie Twittera typu open source, był możliwy do wyboru. Obecnie jest wyświetlany przy użyciu niestandardowego bloku tekstu. Muszę użyć TextBlock, ponieważ pracuję z liniami tekstu bloku, aby wyświetlać i formatować @nazwa_użytkownika i linki jako hiperłącza. Częstym żądaniem jest możliwość skopiowania i wklejenia tekstu. W tym celu należy ustawić opcję TextBlock.

Próbowałem uruchomić go, wyświetlając tekst za pomocą TextBoxa tylko do odczytu, w stylu przypominającym blok tekstowy, ale to nie działa w moim przypadku, ponieważ TextBox nie ma wstawek. Innymi słowy, nie mogę stylizować ani formatować tekstu w TextBox indywidualnie, tak jak mogę to zrobić z TextBlock.

Jakieś pomysły?

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

Wszystkie odpowiedzi tutaj używają po prostu TextBoxlub próbują zaimplementować zaznaczenie tekstu ręcznie, co prowadzi do niskiej wydajności lub nienatywnego zachowania (mruganie okiem TextBox, brak obsługi klawiatury w implementacjach ręcznych itp.)

Po wielu godzinach przekopywania się i czytaniu kodu źródłowego WPF , zamiast tego odkryłem sposób na włączenie natywnego zaznaczania tekstu WPF dla TextBlockformantów (lub naprawdę innych formantów). Większość funkcji związanych z zaznaczaniem tekstu jest zaimplementowana w System.Windows.Documents.TextEditorklasie systemowej.

Aby włączyć zaznaczanie tekstu dla swojej kontroli, musisz zrobić dwie rzeczy:

1. Zadzwoń TextEditor.RegisterCommandHandlers()raz, aby zarejestrować procedury obsługi zdarzeń klasowych

2. Tworzenie instancji TextEditordla każdej instancji klasy i przekazać podstawową otworzonym System.Windows.Documents.ITextContainerdo niego

Istnieje również wymóg, aby Focusablewłaściwość kontroli była ustawiona na True.

To jest to! Brzmi łatwo, ale niestety TextEditorklasa jest oznaczona jako wewnętrzna. Musiałem więc napisać wokół niego opakowanie refleksyjne:

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);
    }
}

Stworzyłem również SelectableTextBlockpochodną, TextBlockktóra wykonuje czynności wymienione powyżej:

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);
    }
}

Inną opcją byłoby utworzenie dołączonej właściwości TextBlockumożliwiającej zaznaczanie tekstu na żądanie. W takim przypadku, aby ponownie wyłączyć zaznaczenie, należy odłączyć a TextEditorza pomocą równoważnika odbicia tego kodu:

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

Nie znalazłem żadnego przykładu odpowiedzi na pytanie. Wszystkie odpowiedzi wykorzystały pole tekstowe lub RichTextbox. Potrzebowałem rozwiązania, które pozwoliło mi korzystać z TextBlock, i właśnie to stworzyłem.

Uważam, że poprawnym sposobem jest rozszerzenie klasy TextBlock. To jest kod, którego użyłem do rozszerzenia klasy TextBlock, aby umożliwić mi zaznaczenie tekstu i skopiowanie go do schowka. „sdo” to odniesienie do przestrzeni nazw, której użyłem w WPF.

WPF przy użyciu klasy rozszerzonej:

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>

Kod za klasą rozszerzoną:

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);
        }
    }
}

Przykładowy kod okna:

    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);
    }

Zastosuj ten styl do TextBox i to wszystko (inspirowane tym artykułem ):

<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>

Utwórz ControlTemplate dla TextBlock i umieść TextBox wewnątrz z zestawem właściwości tylko do odczytu. Lub po prostu użyj TextBox i uczyń go tylko do odczytu, a następnie możesz zmienić TextBox.Style, aby wyglądał jak TextBlock.

Nie jestem pewien, czy możesz ustawić TextBlock do wyboru, ale inną opcją byłoby użycie RichTextBox - jest jak TextBox, jak sugerowałeś, ale obsługuje odpowiednie formatowanie.

Według Windows Dev Center :

TextBlock.IsTextSelectionEnabled właściwość

[Zaktualizowano dla aplikacji UWP na Windows 10. Artykuły na temat Windows 8.x, zobacz archiwum ]

Pobiera lub ustawia wartość wskazującą, czy zaznaczanie tekstu jest włączone w TextBlock , poprzez akcję użytkownika lub wywołanie interfejsu API związanego z wyborem.

Chociaż pytanie brzmi „do wyboru”, uważam, że zamierzonym rezultatem jest przeniesienie tekstu do schowka. Można to łatwo i elegancko osiągnąć poprzez dodanie menu kontekstowego i pozycji menu o nazwie kopiowanie, która umieszcza wartość właściwości Textblock Text w schowku. W każdym razie tylko pomysł.

TextBlock nie ma szablonu. Aby to osiągnąć, musimy użyć TextBox, którego styl został zmieniony, aby zachowywał się jak TextBlock.

<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>

Istnieje alternatywne rozwiązanie, które można dostosować do RichTextBox, zamieszczonego w tym poście na blogu - użyło wyzwalacza, aby zamienić szablon kontrolny, gdy najechanie kursorem na kontrolę - powinno pomóc w wydajności

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
         }
};

Dodanie do odpowiedzi @ torvin i jak wspomniano w komentarzach @Dave Huang, jeśli TextTrimming="CharacterEllipsis"włączyłeś aplikację, ulega awarii po najechaniu kursorem na elipsę.

Wypróbowałem inne opcje wymienione w wątku dotyczące korzystania z TextBox, ale tak naprawdę nie wydaje się to rozwiązaniem, ponieważ nie pokazuje „elipsy”, a także jeśli tekst jest zbyt długi, aby zmieścił się w pojemniku, wybierając zawartość pole tekstowe „przewija się” wewnętrznie, co nie jest zachowaniem TextBlock.

Myślę, że najlepszym rozwiązaniem jest odpowiedź @ torvina, ale ma paskudną awarię podczas najechania na elipsę.

Wiem, że to nie jest ładne, ale subskrybowanie / wypisywanie się wewnętrznie z nieobsługiwanymi wyjątkami i obsługa wyjątku była jedynym sposobem, w jaki znalazłem rozwiązanie tego problemu, proszę podziel się, jeśli ktoś ma lepsze rozwiązanie :)

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;
            }
        }
    }
}

Zaimplementowałem SelectableTextBlock w mojej bibliotece kontrolek opensource. Możesz użyć tego w następujący sposób:

<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 !

Wprowadzam małe modyfikacje

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;
    }
}