WPF TextBlock mettre en évidence certaines parties basées sur la recherche d'condition

J'ai pris dthrasers répondre et a pris le besoin d'un analyseur XML. Il fait un très bon travail en expliquant les pièces en son blog, Cependant cela n'a pas besoin de moi pour ajouter toutes les bibliothèques additionnelles, voici comment je l'ai fait.

Étape, faire une classe de convertisseur:

class StringToXamlConverter : IValueConverter
{
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
string input = value as string;
if (input != null)
{
var textBlock = new TextBlock();
textBlock.TextWrapping = TextWrapping.Wrap;
string escapedXml = SecurityElement.Escape(input);
while (escapedXml.IndexOf("|~S~|") != -1) {
//up to |~S~| is normal
textBlock.Inlines.Add(new Run(escapedXml.Substring(0, escapedXml.IndexOf("|~S~|"))));
//between |~S~| and |~E~| is highlighted
textBlock.Inlines.Add(new Run(escapedXml.Substring(escapedXml.IndexOf("|~S~|") + 5,
escapedXml.IndexOf("|~E~|") - (escapedXml.IndexOf("|~S~|") + 5))) 
{ FontWeight = FontWeights.Bold, Background= Brushes.Yellow });
//the rest of the string (after the |~E~|)
escapedXml = escapedXml.Substring(escapedXml.IndexOf("|~E~|") + 5);
}
if (escapedXml.Length > 0)
{
textBlock.Inlines.Add(new Run(escapedXml));                      
}
return textBlock;
}
return null;
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
throw new NotImplementedException("This converter cannot be used in two-way binding.");
}
}

Étape deux:
Au lieu d'un TextBlock utiliser un ContentBlock. Passer dans la chaîne (vous utilisé pour votre textBlock) pour le bloc de contenu, comme suit:

<ContentControl
Margin="7,0,0,0"
HorizontalAlignment="Left"
VerticalAlignment="Center"
Content="{Binding Description, Converter={StaticResource CONVERTERS_StringToXaml}, Mode=OneTime}">
</ContentControl>

Étape trois:
Assurez-vous que le test que vous transmettez est segmenté avec |~S~| et |~E~|. Et laissez-la mise en évidence de commencer!

Notes:

Vous pouvez changer le style dans la course à déterminer en quoi et comment votre texte est mis en surbrillance

Assurez-vous d'ajouter votre Convertisseur de classe à votre espace de noms et de ressources. Cela peut aussi nécessiter une reconstruction de se mettre au travail.

OriginalL'auteur SyntaxRules

J'ai eu un problème similaire - en essayant de mettre en œuvre une recherche de texte dans une charge de présentateurs que, fondamentalement, représente un rapport. Le rapport a été écrit à l'origine en une chaîne et nous de mettre à profit FlowDocumentViewer intégré ctrl-F - il n'est pas très bon et a quelques-uns bizarre, mais était suffisant.

Si vous voulez juste quelque chose comme ça vous pouvez effectuer les opérations suivantes:

        <FlowDocumentScrollViewer>
<FlowDocument>
<Paragraph FontFamily="Lucida Console" FontSize="12">
<Run Text="{Binding Content, Mode=OneWay}"/>
</Paragraph>
</FlowDocument>
</FlowDocumentScrollViewer>

Nous avons décidé d'aller pour une réécriture que le rapport est en phase avec le reste de la programmation, et fondamentalement chaque éditer les modifications, avoir à recréer l'intégralité du rapport, à chaque fois, signifie que c'est assez lent. Nous avons voulu améliorer ce en se déplaçant à une mise à jour de-la-bits-vous-avez-besoin-pour modèle, mais nécessaire pour avoir du modèle de vue (plutôt que de simplement une chaîne de caractères) pour être en mesure de le faire dans un façon saine! Nous avons voulu préserver la recherche de la fonctionnalité avant de retirer le rapport, cependant, et aller mieux et ont de mettre en évidence le "courant" de la position de recherche dans une couleur et d'autres résultats de recherche dans un autre.

Voici une version simplifiée de ma solution; une classe qui dérive de TextBlock qui ajoute une propriété de dépendance de Type HighlightingInformation. Je n'ai pas compris l'espace de noms et de l'usage qu'ils sont sensibles.

public class HighlightingTextBlock : TextBlock
{
public static readonly DependencyProperty HighlightingProperty =
DependencyProperty.Register("Highlighting", typeof (HighlightingInformation), typeof (HighlightingTextBlock));
public HighlightingInformation Highlighting
{
get { return (HighlightingInformation)GetValue(HighlightingProperty); }
set { SetValue(HighlightingProperty, value); }
}
public HighlightingTextBlock()
{
AddValueChangedCallBackTo(HighlightingProperty, UpdateText);
}
private void AddValueChangedCallBackTo(DependencyProperty property, Action updateAction)
{
var descriptor = DescriptorFor(property);
descriptor.AddValueChanged(this, (src, args) => updateAction());
}
private DependencyPropertyDescriptor DescriptorFor(DependencyProperty property)
{
return DependencyPropertyDescriptor.FromProperty(property, GetType());
}
private void UpdateText()
{
var highlighting = Highlighting;
if (highlighting == null)
return;
highlighting.SetUpdateMethod(UpdateText);
var runs = highlighting.Runs;
Inlines.Clear();
Inlines.AddRange(runs);
}
}

Le type de cette classe peuvent être liées à des utilisations de la méthode de mise à jour lorsque c'est le texte et la liste des faits saillants sont modifiés pour mettre à jour la liste des Pistes. Les faits saillants se ressembler à quelque chose comme ceci:

public class Highlight
{
private readonly int _length;
private readonly Brush _colour;
public int Start { get; private set; }
public Highlight(int start, int length,Brush colour)
{
Start = start;
_length = length;
_colour = colour;
}
private string TextFrom(string currentText)
{
return currentText.Substring(Start, _length);
}
public Run RunFrom(string currentText)
{
return new Run(TextFrom(currentText)){Background = _colour};
}
}

Pour produire la bonne collection phare est un autre problème, qui en gros, j'ai résolu par le traitement de la collecte des présentateurs comme un Arbre qui vous récursive de recherche pour le contenu - les nœuds feuilles sont ceux qui ont un contenu et d'autres nœuds ont des enfants. Si vous effectuez une recherche en profondeur d'abord, vous obtenez l'ordre que vous attendez. Vous pouvez simplement écrire un wrapper autour de la liste des résultats de garder une trace de la position. Im ne va pas à poster tout le code de ma réponse ici, il est de documenter la façon dont vous pouvez faire wpf n'multi-couleur de mise en surbrillance dans le MVP de style.

Je n'ai pas utilisé INotifyPropertyChanged ou CollectionChanged ici que nous n'avons pas besoin de modifications pour être multi-cast (par exemple, une participante a de multiples points de vue). Au départ, j'ai essayé de le faire par l'ajout d'un événement modifié de notification pour le Texte et l'autre pour une liste (vous avez également manuellement abonnez-vous à la INotifyCollectionChanged événement). J'ai eu des préoccupations au sujet des fuites de mémoire de l'événement, des cotisations, cependant, et le fait que les mises à jour pour le texte et le met en évidence n'est pas venu dans le même temps fait-il problématique.

Le seul inconvénient de cette approche est que les gens ne devraient pas se lier à la propriété Text de ce contrôle. Dans la vraie version, j'ai ajouté quelques vérifications + exception de lancer à empêcher les gens de le faire, mais oublié de l'exemple pour plus de clarté!

OriginalL'auteur JonnyRaa

Ici, je présente une autre Approche pour la mise en évidence de texte. J'ai eu un cas d'utilisation où j'avais besoin pour décorer un tas de Code C#, WPF, cependant, je ne veux pas utiliser textBlock.Inlines.Ajoutez le type de syntaxe, au lieu de cela, je voulais générer la mise en évidence XAML à la volée, puis ajouter dynamiquement à une Toile ou tout autre contenant en WPF.

Supposons donc que vous voulez coloriser le morceau de code suivant et également mettre en valeur une partie de celui-ci:

public static void TestLoop(int count)
{ 
for(int i=0;i<count;i++)
Console.WriteLine(i);
}

Supposons que le code ci-dessus se trouve dans un fichier appelé Test.txt .
Supposons que vous voulez coloriser tous les C# mots-clés (public, static void etc..) et les types simples(int, string) en Bleu, et la Console.WriteLine mis en évidence en jaune.

L'étape 0. Créer une nouvelle Application WPF et comprennent un exemple de code similaire à ci-dessus dans un fichier appelé Test.txt

L'étape 1. Créer un Code Surligneur classe:

using System.IO;
using System.Text;
public enum HighLightType
{
Type = 0,
Keyword = 1,
CustomTerm = 2
}
public class CodeHighlighter
{
public static string[] KeyWords = { "public", "static", "void", "return", "while", "for", "if" };
public static string[] Types = { "string", "int", "double", "long" };
private string FormatCodeInXaml(string code, bool withLineBreak)
{
string[] mapAr = { "<","&lt;" , //Replace less than sign
">","&gt;" }; //Replace greater than sign
StringBuilder sb = new StringBuilder();
using (StreamReader sr = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(code))))
{
while (!sr.EndOfStream)
{
string line = sr.ReadLine();
line = line.Replace("\t", "&#160;&#160;&#160;&#160;"); //Replace tabs
line = line.Replace(" ", "&#160;"); //Replace spaces
for (int i = 0; i < mapAr.Length; i += 2)
line = line.Replace(mapAr[i], mapAr[i + 1]);
if (withLineBreak)
sb.AppendLine(line + "<LineBreak/>"); //Replace line breaks
else
sb.AppendLine(line);
}
}
return sb.ToString();
}
private string BuildForegroundTag(string highlightText, string color)
{
return "<Span Foreground=\"" + color + "\">" + highlightText + "</Span>";
}
private string BuildBackgroundTag(string highlightText, string color)
{
return "<Span Background=\"" + color + "\">" + highlightText + "</Span>";
}
private string HighlightTerm(HighLightType type, string term, string line)
{
if (term == string.Empty)
return line;
string keywordColor = "Blue";
string typeColor = "Blue";
string statementColor = "Yellow";
if (type == HighLightType.Type)
return line.Replace(term, BuildForegroundTag(term, typeColor));
if (type == HighLightType.Keyword)
return line.Replace(term, BuildForegroundTag(term, keywordColor));
if (type == HighLightType.CustomTerm)
return line.Replace(term, BuildBackgroundTag(term, statementColor));
return line;
}
public string ApplyHighlights(string code, string customTerm)
{
code = FormatCodeInXaml(code, true);
customTerm = FormatCodeInXaml(customTerm, false).Trim();
StringBuilder sb = new StringBuilder();
using (StreamReader sr = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(code))))
{
while (!sr.EndOfStream)
{
string line = sr.ReadLine();
line = HighlightTerm(HighLightType.CustomTerm, customTerm, line);
foreach (string keyWord in KeyWords)
line = HighlightTerm(HighLightType.Keyword, keyWord, line);
foreach (string type in Types)
line = HighlightTerm(HighLightType.Type, type, line);
sb.AppendLine(line);
}
}
return sb.ToString();
}
}

L'étape 2. Ajouter une Toile XAML tag à votre MainWindow.xaml

<Window x:Class="TestCodeVisualizer.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:local="clr-namespace:TestCodeVisualizer"
mc:Ignorable="d"
Title="MainWindow" Height="350" Width="525">
<Canvas Name="canvas" />
</Window>

L'étape 3. Dans Votre Application WPF ajoutez le code suivant: (assurez-vous que test.txt est au bon endroit) :

using System.Text;
using System.IO;
using System.Windows;
using System.Windows.Markup;
namespace TestCodeVisualizer
{
///<summary>
///Interaction logic for MainWindow.xaml
///</summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
string testText = File.ReadAllText("Test.txt");
FrameworkElement fe = GenerateHighlightedTextBlock(testText, "Console.WriteLine");
this.canvas.Children.Add(fe);
}
private FrameworkElement GenerateHighlightedTextBlock(string code, string term)
{
CodeHighlighter ch = new CodeHighlighter();
string uc = "<UserControl xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation' xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>[CONTENT]</UserControl>";
string content = "<TextBlock>" + ch.ApplyHighlights(code, term) + "</TextBlock>";
uc = uc.Replace("[CONTENT]", content);
FrameworkElement fe = XamlReader.Load(new System.IO.MemoryStream(Encoding.UTF8.GetBytes(uc))) as FrameworkElement;
return fe;
}
}
}

OriginalL'auteur Alex Begun

Si vous êtes à la manipulation ContainerContentChanging pour votre ListViewBase, vous pouvez prendre les méthodes suivantes: TextBlock mise en évidence pour WinRT/ContainerContentChanging

Veuillez noter que ce code est pour Windows RT. WPF de la syntaxe légèrement différente. Notez également que si vous utilisez la liaison à remplir le TextBlock.Propriété de texte, le texte généré par mon approche sera écrasé. J'utilise ContainerContentChanging pour remplir les champs de cibles en raison de radicalement-augmentation de la performance et des améliorations dans l'utilisation de la mémoire, par rapport à la normale de liaison. J'utilise la liaison uniquement pour gérer les données de source, pas de la vue de données.

OriginalL'auteur Mark Jones