SyntaxColorizer 1.0.2

SyntaxColorizer

A syntax-highlighting TextBox control for Avalonia with support for multiple programming languages. Built using only native Avalonia features without external dependencies.

<details> <summary>More Screenshots</summary>

</details>

Features

• Real-time syntax highlighting as you type
• Support for 37 programming languages
• 14 built-in color themes
• Line numbers display (toggleable)
• Linting infrastructure with customizable rules
• MVVM-friendly design
• NuGet package ready

Supported Languages

Installation

From NuGet (Recommended)

Install via the .NET CLI:

dotnet add package SyntaxColorizer

Or via the Package Manager Console in Visual Studio:

Install-Package SyntaxColorizer

Or add directly to your .csproj:

<ItemGroup>
  <PackageReference Include="SyntaxColorizer" Version="1.0.0" />
</ItemGroup>

From Source

1. Clone the repository
2. Build the solution:

   dotnet build
   

3. Add a project reference to your Avalonia application:

   <ItemGroup>
     <ProjectReference Include="path/to/SyntaxColorizer/SyntaxColorizer.csproj" />
   </ItemGroup>
   

Usage

1. Add the Styles

In your App.axaml, include the SyntaxColorizer styles:

<Application.Styles>
    <FluentTheme />
    <StyleInclude Source="avares://SyntaxColorizer/Controls/SyntaxHighlightingTextBox.axaml" />
</Application.Styles>

2. Add the Namespace

In your XAML file, add the namespace:

xmlns:controls="clr-namespace:SyntaxColorizer.Controls;assembly=SyntaxColorizer"

3. Use the Control

<controls:SyntaxHighlightingTextBox
    Language="CSharp"
    SyntaxTheme="{x:Static themes:BuiltInThemes.VisualStudioDark}"
    ShowLineNumbers="True"
    FontSize="14" />

Code-Behind Example

using SyntaxColorizer;
using SyntaxColorizer.Controls;
using SyntaxColorizer.Themes;

// Set the language
editor.Language = SyntaxLanguage.CSharp;

// Set the theme
editor.SyntaxTheme = BuiltInThemes.VisualStudioDark;

// Get/set text
editor.Text = "public class Hello { }";

// Show/hide line numbers
editor.ShowLineNumbers = true;

Available Properties

Built-in Themes

using SyntaxColorizer.Themes;

// Light themes
var vsLight = BuiltInThemes.VisualStudioLight;
var githubLight = BuiltInThemes.GitHubLight;
var solarizedLight = BuiltInThemes.SolarizedLight;
var oneLight = BuiltInThemes.OneLight;
var gruvboxLight = BuiltInThemes.GruvboxLight;
var quietLight = BuiltInThemes.QuietLight;

// Dark themes
var vsDark = BuiltInThemes.VisualStudioDark;
var monokai = BuiltInThemes.Monokai;
var githubDark = BuiltInThemes.GitHubDark;
var solarizedDark = BuiltInThemes.SolarizedDark;
var dracula = BuiltInThemes.Dracula;
var oneDark = BuiltInThemes.OneDark;
var nord = BuiltInThemes.Nord;
var gruvboxDark = BuiltInThemes.GruvboxDark;

Linting

The control includes a linting infrastructure for displaying code hints:

using SyntaxColorizer.Linting;

// Get a linter for the current language
var linter = LinterFactory.GetLinter(editor.Language);

// Run analysis
var hints = linter.Analyze(editor.Text);

// Add hints to the editor
foreach (var hint in hints)
{
    editor.AddLintingHint(hint);
}

// Clear all hints
editor.ClearLintingHints();

Creating Custom Linting Rules

using System.Text.RegularExpressions;
using SyntaxColorizer.Linting;

var linter = new CommonLinter(SyntaxLanguage.CSharp);
linter.AddRule(new LintingRule
{
    Pattern = new Regex(@"\bmagic\b", RegexOptions.IgnoreCase),
    Message = "Avoid using magic values",
    Severity = LintingSeverity.Warning,
    Code = "CUSTOM001"
});

Adding New Language Support

1. Create a new tokenizer class in Tokenization/Languages/:

using System.Text.RegularExpressions;
using SyntaxColorizer.Tokenization;

public class MyLanguageTokenizer : LanguageTokenizerBase
{
    private static readonly IReadOnlyList<TokenPattern> _patterns;
    private static readonly IReadOnlyDictionary<string, TokenType> _keywords;

    static MyLanguageTokenizer()
    {
        _keywords = new Dictionary<string, TokenType>
        {
            ["if"] = TokenType.ControlKeyword,
            ["else"] = TokenType.ControlKeyword,
            // ... more keywords
        };

        _patterns = new List<TokenPattern>
        {
            new(CommonPatterns.SingleLineComment, TokenType.Comment, 9),
            new(CommonPatterns.DoubleQuotedString, TokenType.String, 6),
            new(CommonPatterns.Identifier, TokenType.Identifier, 2),
            // ... more patterns
        };
    }

    public override SyntaxLanguage Language => SyntaxLanguage.MyLanguage;
    protected override IReadOnlyList<TokenPattern> Patterns => _patterns;
    protected override IReadOnlyDictionary<string, TokenType>? Keywords => _keywords;
}

2. Add the language to the SyntaxLanguage enum in SyntaxLanguage.cs

3. Register the tokenizer in TokenizerFactory.cs:

SyntaxLanguage.MyLanguage => new MyLanguageTokenizer(),

Project Structure

SyntaxColorizer/
├── src/
│   ├── SyntaxColorizer/              # Main library
│   │   ├── Controls/                  # UI controls
│   │   ├── Linting/                   # Linting infrastructure
│   │   ├── Themes/                    # Color themes
│   │   └── Tokenization/              # Tokenizers
│   │       └── Languages/             # Language-specific tokenizers
│   └── SyntaxColorizer.Demo/          # Demo application
├── SyntaxColorizer.sln
└── README.md

Running the Demo

cd src/SyntaxColorizer.Demo
dotnet run

The demo application demonstrates:

• Switching between languages
• Changing themes
• Line number toggle
• Running the linter

License

MIT License - see LICENSE file for details.

Contributing

Contributions are welcome! Feel free to:

• Add support for new languages
• Create new color themes
• Improve tokenizer accuracy
• Add new linting rules
• Fix bugs and improve performance