Вопрос по textblock, wpf-controls, wpf – Количество видимых строк TextBlock

8

Если для TextWrapping установлено значение «Обтекание», текстовый блок WPF может содержать несколько строк текста. Есть ли "чистый" способ получить количество строк текста? Я подумал о том, чтобы посмотреть на желаемую высоту и разделить ее на предполагаемую высоту каждой линии. Однако это выглядит довольно грязно. Есть ли способ лучше?

Ваш Ответ

4   ответа
8

что все элементы управления выглядят очень неприглядно. Из-за этого мы можем использоватьТекстовое окн, у которого есть свойство LineCount (почему это не DependencyProperty или почему TextBlock также не имеет его, я не знаю). С помощью TextBox мы можем просто изменить его шаблон, чтобы он вел себя и выглядел больше как TextBlock. В нашем пользовательском стиле / шаблоне мы собираемся установить для IsEnabled значение False и просто создадим базовый повторный шаблон элемента управления, чтобы отключенный вид больше не присутствовал. Мы также можем связать любые свойства, которые мы хотим сохранить, например, Background, используя TemplateBindings.

<Style x:Key="Local_TextBox"
    TargetType="{x:Type TextBoxBase}">
    <Setter Property="IsEnabled"
            Value="False" />
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="{x:Type TextBoxBase}">
                <Border Name="Border"
                    Background="{TemplateBinding Background}">
                    <ScrollViewer x:Name="PART_ContentHost" />
                </Border>
            </ControlTemplate>
        </Setter.Value>
</Setter>
</Style>

Теперь это позаботится о том, чтобы наш TextBox выглядел и вел себя как TextBlock, но как мы можем получить количество строк?

Хорошо, если мы хотим получить к нему доступ непосредственно в коде, то можем зарегистрироваться на событие TextCox SizeChanged.

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

        LongText = "This is a long line that has lots of text in it.  Because it is a long line, if a TextBlock's TextWrapping property is set to wrap then the text will wrap onto new lines. However, we can also use wrapping on a TextBox, that has some diffrent properties availible and then re-template it to look just like a TextBlock!";

        uiTextBox.SizeChanged += new SizeChangedEventHandler(uiTextBox_SizeChanged);

        this.DataContext = this;
    }

    void uiTextBox_SizeChanged(object sender, SizeChangedEventArgs e)
    {
        Lines = uiTextBox.LineCount;
    }

    public string LongText { get; set; }

    public int Lines
    {
        get { return (int)GetValue(LinesProperty); }
        set { SetValue(LinesProperty, value); }
    }

    // Using a DependencyProperty as the backing store for Lines.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty LinesProperty =
        DependencyProperty.Register("Lines", typeof(int), typeof(MainWindow), new UIPropertyMetadata(-1));
}

Однако, поскольку мне, как правило, нужно использовать такие свойства в местах, отличных от текущего окна, и / или я использую MVVM и не хочу использовать этот подход, то мы можем создать некоторые AttachedProperties для обработки поиска и установки LineCount. Мы собираемся использовать AttachedProperties, чтобы сделать то же самое, но теперь мы сможем использовать его с любым TextBox в любом месте и привязывать к нему через этот TextBox вместо DataContext окна.

public class AttachedProperties
{
    #region BindableLineCount AttachedProperty
    public static int GetBindableLineCount(DependencyObject obj)
    {
        return (int)obj.GetValue(BindableLineCountProperty);
    }

    public static void SetBindableLineCount(DependencyObject obj, int value)
    {
        obj.SetValue(BindableLineCountProperty, value);
    }

    // Using a DependencyProperty as the backing store for BindableLineCount.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty BindableLineCountProperty =
        DependencyProperty.RegisterAttached(
        "BindableLineCount",
        typeof(int),
        typeof(MainWindow),
        new UIPropertyMetadata(-1));

    #endregion // BindableLineCount AttachedProperty

    #region HasBindableLineCount AttachedProperty
    public static bool GetHasBindableLineCount(DependencyObject obj)
    {
        return (bool)obj.GetValue(HasBindableLineCountProperty);
    }

    public static void SetHasBindableLineCount(DependencyObject obj, bool value)
    {
        obj.SetValue(HasBindableLineCountProperty, value);
    }

    // Using a DependencyProperty as the backing store for HasBindableLineCount.  This enables animation, styling, binding, etc...
    public static readonly DependencyProperty HasBindableLineCountProperty =
        DependencyProperty.RegisterAttached(
        "HasBindableLineCount",
        typeof(bool),
        typeof(MainWindow),
        new UIPropertyMetadata(
            false,
            new PropertyChangedCallback(OnHasBindableLineCountChanged)));

    private static void OnHasBindableLineCountChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        var textBox = (TextBox)o;
        if ((e.NewValue as bool?) == true)
        {
            textBox.SetValue(BindableLineCountProperty, textBox.LineCount);
            textBox.SizeChanged += new SizeChangedEventHandler(box_SizeChanged);
        }
        else
        {
            textBox.SizeChanged -= new SizeChangedEventHandler(box_SizeChanged);
        }
    }

    static void box_SizeChanged(object sender, SizeChangedEventArgs e)
    {
        var textBox = (TextBox)sender;
        (textBox).SetValue(BindableLineCountProperty, (textBox).LineCount);
    }
    #endregion // HasBindableLineCount AttachedProperty
}

Теперь найти LineCount просто:

<StackPanel>
    <TextBox x:Name="uiTextBox"
             TextWrapping="Wrap"
             local:AttachedProperties.HasBindableLineCount="True"
             Text="{Binding LongText}"
             Style="{StaticResource Local_TextBox}" />

    <TextBlock Text="{Binding Lines, StringFormat=Binding through the code behind: {0}}" />
    <TextBlock Text="{Binding ElementName=uiTextBox, Path=(local:AttachedProperties.BindableLineCount), StringFormat=Binding through AttachedProperties: {0}}" />
</StackPanel>
Это здорово. Тем не менее, TextBox более ограничены, чем TextBlock, потому что они имеют единое семейство шрифтов / размер шрифта. В результате, легко рассчитать количество строк. TextBlocks, с другой стороны, могут иметь разные строки с разной высотой. Это несколько усложняет ситуацию. tom7
3
// this seems to do the job        

<TextBox x:Name="DescriptionTextBox"
                         Grid.Row="03"
                         Grid.RowSpan="3"
                         Grid.Column="01"
                         Width="100"
                         AcceptsReturn="True"
                         MaxLength="100"
                         MaxLines="3"
                         PreviewKeyDown="DescriptionTextBox_PreviewKeyDown"
                         Text="{Binding Path=Description,
                                        Mode=TwoWay,
                                        UpdateSourceTrigger=PropertyChanged}"
                         TextWrapping="Wrap" />



        /// <summary>
        /// we need to limit a multi line textbox at entry time
        /// </summary>
        /// <param name="sender">
        /// The sender.
        /// </param>
        /// <param name="e">
        /// The e.
        /// </param>
        private void DescriptionTextBox_PreviewKeyDown(object sender, System.Windows.Input.KeyEventArgs e)
        {
            TextBox thisTextBox = sender as TextBox;
            if (thisTextBox != null)
            {
                // only check if we have passed the MaxLines 
                if (thisTextBox.LineCount > thisTextBox.MaxLines)
                {
                    // we are going to discard the last entered character
                    int numChars = thisTextBox.Text.Length;

                    // force the issue
                    thisTextBox.Text = thisTextBox.Text.Substring(0, numChars - 1);

                    // set the cursor back to the last allowable character
                    thisTextBox.SelectionStart = numChars - 1;

                    // disallow the key being passed in
                    e.Handled = true;
                }
            }
        }
Вопрос был о TextBlock, а не TextBox. jHilscher
1

TextBlock имеет частную собственность под названием LineCount. Я создал метод расширения, чтобы прочитать это значение:

public static class TextBlockExtension
{
    public static int GetLineCount(this TextBlock tb)
    {
        var propertyInfo = GetPrivatePropertyInfo(typeof(TextBlock), "LineCount");
        var result = (int)propertyInfo.GetValue(tb);
        return result;
    }

    private static PropertyInfo GetPrivatePropertyInfo(Type type, string propertyName)
    {
        var props = type.GetProperties(BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.NonPublic);
        return props.FirstOrDefault(propInfo => propInfo.Name == propertyName);
    }
}
-2

tVisibleLineIndex, который позволяет узнать, сколько строк может отображать текстовое поле (без полос прокрутки).

Если вы хотите знать, когда добавляется строка, вы можете услышать о событии TextChanged и спросить о свойстве LineCount (вам нужно будет сохранить las LineCount в переменной, чтобы выполнить сравнение).

TextBlock не имеет свойства LineCount. Это исключительно область TextBox. Mike Post
Я нашел это полезным, хотя. хорошая информация, неправильный ответ. mdw7326

Похожие вопросы