Download NuGet NuGet Purchase

    Properties

    The WpfHtmlEditor control exposes its host-app API primarily as properties on the control instance. These properties fall into a handful of buckets: content properties (such as DocumentHtml, BodyHtml, DocumentTitle) that round-trip the editor's HTML; appearance properties (font defaults, body colour, border) that style the document and the chrome; behavior properties (such as EditorMode, Language, ScrollBarSetting) that switch the control between modes or locales; options aggregates (Options and SpellCheckOptions) that hold the rest of the configurable knobs; and service properties (Content, Caret, Selection, etc.) that expose the underlying engines for programmatic editing.

    Most properties shown here are CLR properties backed by either a WPF DependencyProperty (so they participate in XAML data-binding) or a plain backing field. Where a property is a dependency property, the Remarks section says so explicitly. Properties that read or write the live HTML document (for example BodyHtml or BodyStyle) round-trip through the underlying MSHTML document and require the editor to be in WysiwygDesign mode for the write to take effect on the design surface.

    Throughout this reference, the variable MyEditor refers to a WpfHtmlEditor instance, either created in code-behind or declared in XAML and resolved through x:Name="MyEditor". Properties marked [Browsable(false)] are still public and fully usable from code; they are merely hidden from the WPF designer property grid.

    BackgroundImagePath

    Sets or returns the URL of the image painted as the document body background. The value is persisted into the body element's style attribute as the standard CSS background-image rule, so it survives a round-trip through DocumentHtml. Pass an empty string to remove the background image.

    Syntax
    public string BackgroundImagePath { get; set; }
    Public Property BackgroundImagePath As String
    Property value

    string - absolute URL or file path of the background image; an empty string means no background image.

    Example
    MyEditor.BackgroundImagePath = "file:///C:/skins/paper.jpg";

    BaseUrl

    Sets or returns the base URL the document uses to resolve relative resource paths (images, stylesheets, hyperlinks). Setting this property before assigning HTML lets relative paths in that HTML resolve correctly even when the editor is hosted in a tool where the document's natural location is unknown.

    Syntax
    public string BaseUrl { get; set; }
    Public Property BaseUrl As String
    Property value

    string - a file-system path or HTTP URL used as the base for relative resource references inside the document.

    Remarks

    When EditorMode is EditorModes.HtmlEdit the getter returns an empty string - the source-view text area has no notion of a base URL.

    Example
    // In a Window.Loaded handler:

MyEditor.BaseUrl = System.IO.Path.Combine(

    AppDomain.CurrentDomain.BaseDirectory, "images");

MyEditor.BodyHtml = "<img src='banner.png' />"; // resolves to images\banner.png

    BodyColor

    Sets or returns the document body background colour. The value is persisted into the body element's bgcolor attribute and round-trips through DocumentHtml.

    Syntax
    public System.Windows.Media.Color BodyColor { get; set; }
    Public Property BodyColor As System.Windows.Media.Color
    Property value

    System.Windows.Media.Color - the colour used to fill the body background.

    Example
    MyEditor.BodyColor = System.Windows.Media.Colors.LightYellow;

    BodyCSSClassName

    Sets or returns the value of the class attribute on the document's <body> tag. Combined with a stylesheet (DocumentCSSFilePath or HeaderStyleContent) this lets the host application skin the editor's document from CSS.

    Syntax
    public string BodyCSSClassName { get; set; }
    Public Property BodyCSSClassName As String
    Property value

    string - the CSS class name placed on the document body, or null to clear the attribute.

    Example
    MyEditor.DocumentCSSFilePath = "skins/site.css";

MyEditor.BodyCSSClassName    = "article-body";

    BodyHtml

    Sets or returns the HTML that lives between the <body> and </body> tags. This is the property to bind for the typical case where the host application stores user content but the HTML <head> is owned by the editor (or by the host's own CSS/JS).

    Syntax
    public string BodyHtml { get; set; }
    Public Property BodyHtml As String
    Property value

    string - the inner HTML of the document body. Defaults to an empty string.

    Remarks

    Backed by the dependency property BodyHtmlProperty; binds two-way by default, with UpdateSourceTrigger.LostFocus as the default trigger.

    Example
    // Set from code-behind:

MyEditor.BodyHtml = "<p>Welcome</p>";



// Or bind in XAML:

// <wpf:WpfHtmlEditor x:Name="MyEditor" BodyHtml="{Binding Letter.Body, Mode=TwoWay}" />

    BodyStyle

    Sets or returns the value of the style attribute on the document's <body> tag, allowing inline CSS to be applied or harvested as a single string.

    Syntax
    public string BodyStyle { get; set; }
    Public Property BodyStyle As String
    Property value

    string - the CSS rules placed on the style attribute of the body element.

    Example
    MyEditor.BodyStyle = "margin:8px; background-color:#fefefe; font-family:Calibri";

    BodyStyleAsDOM

    Returns the body element's style object as an MSHTML IHTMLStyle COM pointer, allowing the host app to read or set individual CSS properties without parsing the BodyStyle string.

    Syntax
    public IHTMLStyle BodyStyleAsDOM { get; }
    Public ReadOnly Property BodyStyleAsDOM As IHTMLStyle
    Property value

    mshtml.IHTMLStyle - the live style DOM object for the body.

    Example
    var style = MyEditor.BodyStyleAsDOM;
if (style != null)
{
    style.marginLeft = "12px";
    style.marginRight = "12px";
}
    Dim style = MyEditor.BodyStyleAsDOM

If style IsNot Nothing Then
    style.marginLeft = "12px"
    style.marginRight = "12px"
End If

    Caret

    Returns the caret-manipulation service for the editor. Use this to query or move the caret programmatically (for example, after a custom toolbar action).

    Syntax
    public ICaretService Caret { get; set; }
    Public Property Caret As ICaretService
    Property value

    ICaretService - the caret service instance.

    Example
    // Move the caret to the end of the body, then insert a paragraph:

MyEditor.Caret.MoveCaretToEnd();

MyEditor.Content.InsertHtml("<p>Appended paragraph</p>");

    Charset

    Sets or returns the document's charset (encoding) as declared in the document's <meta> tag.

    Syntax
    public string Charset { get; set; }
    Public Property Charset As String
    Property value

    string - for example "unicode", "utf-8", or "iso-8859-1". Defaults to "unicode".

    Example
    MyEditor.Charset = "utf-8";

    Content

    Returns the content-manipulation service. This is the primary entry point for inserting HTML, loading and saving files, and walking the document's element tree.

    Syntax
    public IContentService Content { get; set; }
    Public Property Content As IContentService
    Property value

    IContentService - the content service. See the Content Service page for the full member list.

    Example
    // Insert a hyperlink at the caret position:

MyEditor.Content.InsertHtml("<a href='https://spicelogic.com'>SpiceLogic</a>");

    DefaultFontFamily

    Sets or returns the default font family for the document body. The value is persisted into the body element's style attribute as the font-family rule, so it round-trips through DocumentHtml. The toolbar's font-name combo is kept in sync.

    Syntax
    public string DefaultFontFamily { get; set; }
    Public Property DefaultFontFamily As String
    Property value

    string - a font family name, e.g. "Calibri" or "Arial".

    Example
    MyEditor.DefaultFontFamily = "Calibri";

    DefaultFontSizeInPt

    Sets or returns the default font size for the document body in points. Numeric values without a unit are interpreted as pixels and converted to points (15 → 11pt). Pass values with the explicit pt suffix to set the size in points directly.

    Syntax
    public string DefaultFontSizeInPt { get; set; }
    Public Property DefaultFontSizeInPt As String
    Property value

    string - the body font size in points, e.g. "11pt".

    Example
    MyEditor.DefaultFontSizeInPt = "14pt";

    DefaultForeColor

    Sets or returns the default foreground (text) colour for the document body. The value is persisted into the body style attribute as color and round-trips through DocumentHtml.

    Syntax
    public System.Windows.Media.Color DefaultForeColor { get; set; }
    Public Property DefaultForeColor As System.Windows.Media.Color
    Property value

    System.Windows.Media.Color - defaults to Colors.Black.

    Example
    MyEditor.DefaultForeColor = System.Windows.Media.Color.FromRgb(0x22, 0x22, 0x22);

    Dialog

    Returns the dialog service used by the built-in toolbar to show the editor's modal dialogs (Insert Image, Find & Replace, etc.). Useful for invoking the editor's native dialogs from custom toolbar items.

    Syntax
    public IDialogService Dialog { get; set; }
    Public Property Dialog As IDialogService
    Property value

    IDialogService - the dialog service.

    Example
    // Open the built-in Insert Image dialog from a custom button:

BtnInsertImage.Click += (s, e) => MyEditor.Dialog.ShowInsertImageDialog();

    DocumentCSSFilePath

    Sets or returns the URL of an external CSS file linked from the document head. Setting this property writes (or updates) a <link rel="stylesheet"> element identified by Options.DefaultCssFileLinkNameAttribute.

    Syntax
    public string DocumentCSSFilePath { get; set; }
    Public Property DocumentCSSFilePath As String
    Property value

    string - absolute or relative URL of the stylesheet; an empty string removes the link.

    Example
    MyEditor.DocumentCSSFilePath = "file:///C:/skins/article.css";

    DocumentHtml

    Sets or returns the entire HTML document including the <html>, <head>, and <body> markup. Use this in preference to BodyHtml when the host application owns the full document (custom doctype, charset, header style block).

    Syntax
    public string DocumentHtml { get; set; }
    Public Property DocumentHtml As String
    Property value

    string - the full HTML document as a single string.

    Remarks

    Backed by the dependency property DocumentHtmlProperty; binds two-way by default, with UpdateSourceTrigger.LostFocus as the default trigger.

    Example
    // Save the full document to disk:

System.IO.File.WriteAllText("page.html", MyEditor.DocumentHtml);



// Load a document from disk back into the editor:

MyEditor.DocumentHtml = System.IO.File.ReadAllText("page.html");

    DocumentTitle

    Sets or returns the value of the <title> element in the document head.

    Syntax
    public string DocumentTitle { get; set; }
    Public Property DocumentTitle As String
    Property value

    string - the document title; defaults to empty.

    Remarks

    Backed by the dependency property DocumentTitleProperty; binds two-way by default.

    Example
    MyEditor.DocumentTitle = "Customer Welcome Letter";
this.Title = MyEditor.DocumentTitle; // mirror to the Window caption
    MyEditor.DocumentTitle = "Customer Welcome Letter"
Me.Title = MyEditor.DocumentTitle ' mirror to the Window caption

    Editor

    Returns the lower-level editor service that owns scrolling, focus, and design-mode toggling.

    Syntax
    public IEditorServiceBase Editor { get; set; }
    Public Property Editor As IEditorServiceBase
    Property value

    IEditorServiceBase - the editor service.

    Example
    // Wire a host-app Undo button to the editor:

BtnUndo.Click += (s, e) => MyEditor.Editor.Undo();

    EditorBorderColor

    Sets or returns the colour of the border drawn around the editor surface. Set the value to default(Color) to fall back to the theme default at design time.

    Syntax
    public System.Windows.Media.Color EditorBorderColor { get; set; }
    Public Property EditorBorderColor As System.Windows.Media.Color
    Property value

    System.Windows.Media.Color - editor border colour.

    Example
    MyEditor.EditorBorderColor = System.Windows.Media.Colors.SteelBlue;

    EditorBorderWidth

    Sets or returns the thickness of the editor border. Set the value to new Thickness(0) to hide the border entirely.

    Syntax
    public System.Windows.Thickness EditorBorderWidth { get; set; }
    Public Property EditorBorderWidth As System.Windows.Thickness
    Property value

    System.Windows.Thickness - editor border thickness.

    Example
    // Hide the border entirely for an embedded edit-in-place look:
MyEditor.EditorBorderWidth = new System.Windows.Thickness(0);
    ' Hide the border entirely for an embedded edit-in-place look:
MyEditor.EditorBorderWidth = New System.Windows.Thickness(0)

    EditorContextMenuStrip

    Sets or returns the WPF ContextMenu used when the user right-clicks inside the editing surface. Replaces the built-in context menu.

    Syntax
    public System.Windows.Controls.ContextMenu EditorContextMenuStrip { get; set; }
    Public Property EditorContextMenuStrip As System.Windows.Controls.ContextMenu
    Property value

    ContextMenu - the custom context menu, or null to keep the default.

    Example
    var menu = new System.Windows.Controls.ContextMenu();
var item = new System.Windows.Controls.MenuItem
{
    Header = "Insert Customer Name"
};
item.Click += (s, e) => MyEditor.Content.InsertHtml("{{customer}}");
menu.Items.Add(item);
MyEditor.EditorContextMenuStrip = menu;
        Dim menu = New System.Windows.Controls.ContextMenu()
    Dim item = New System.Windows.Controls.MenuItem With {
.Header = "Insert Customer Name"
    }
    item.Click += Function(s, e) MyEditor.Content.InsertHtml("{{customer}}")
    menu.Items.Add(item)
    MyEditor.EditorContextMenuStrip = menu

    EditorMode

    Sets or returns the editor's current view: design (WYSIWYG), HTML source, or preview. Changing the mode at runtime triggers a synchronous re-layout of the editor chrome.

    Syntax
    public EditorModes EditorMode { get; set; }
    Public Property EditorMode As EditorModes
    Property value

    EditorModes - one of WysiwygDesign (default), HtmlEdit, or Preview.

    Remarks

    Backed by the dependency property EditorModeProperty.

    Example
    // Toggle to source mode so the user can hand-edit the HTML:

MyEditor.EditorMode = EditorModes.HtmlEdit;

    Focused

    Returns whether the editor (or any of its inner controls) currently has the keyboard focus.

    Syntax
    public bool Focused { get; }
    Public ReadOnly Property Focused As Boolean
    Property value

    bool - true if the editor has input focus; otherwise false.

    Example
    // Only auto-save while the user is typing into the editor:
if (MyEditor.Focused)
    AutoSave(MyEditor.DocumentHtml);
    ' Only auto-save while the user is typing into the editor:
If MyEditor.Focused Then AutoSave(MyEditor.DocumentHtml)

    Formatting

    Returns the formatting service used to apply bold, italic, lists, alignment, and similar text formatting to the current selection.

    Syntax
    public IFormattingService Formatting { get; set; }
    Public Property Formatting As IFormattingService
    Property value

    IFormattingService - the formatting service.

    Example
    // Bold the current selection from a custom toolbar button:

BtnBold.Click += (s, e) => MyEditor.Formatting.ToggleBold();

    HeaderStyleContent

    Sets or returns the CSS rules inside the <style> block identified by HeaderStyleContentElementID in the document head. Use this to inject document-scoped CSS without rewriting the whole document head.

    Syntax
    public string HeaderStyleContent { get; set; }
    Public Property HeaderStyleContent As String
    Property value

    string - the CSS rules to place inside the named <style> element.

    Example
    MyEditor.HeaderStyleContentElementID = "page_style";

MyEditor.HeaderStyleContent = "p { line-height: 1.5; } a { color: #06c; }";

    HeaderStyleContentElementID

    Sets or returns the id attribute of the head <style> element controlled by HeaderStyleContent. Changing this id at runtime removes the previous <style id="..."> element from the document, so the document never accumulates stale style blocks.

    Syntax
    public string HeaderStyleContentElementID { get; set; }
    Public Property HeaderStyleContentElementID As String
    Property value

    string - defaults to "page_style".

    Example
    MyEditor.HeaderStyleContentElementID = "reader-theme";

    HorizontalScrollPosition

    Returns the editor's current horizontal scroll position in pixels. Always returns 0 when the editor is in HTML-source mode.

    Syntax
    public int HorizontalScrollPosition { get; }
    Public ReadOnly Property HorizontalScrollPosition As Integer
    Property value

    int - horizontal scroll offset in pixels.

    Example
    int x = MyEditor.HorizontalScrollPosition;
if (x > 0)
    System.Diagnostics.Debug.WriteLine("Document is wider than the viewport.");
    Dim x As Integer = MyEditor.HorizontalScrollPosition
If x > 0 Then System.Diagnostics.Debug.WriteLine("Document is wider than the viewport.")

    KeyBindings

    Returns the manager used to bind, rebind, override, or disable keyboard shortcuts on the editor. Parallel to ToolbarItemOverrider - where the overrider intercepts toolbar clicks, this manager intercepts keystrokes.

    Syntax
    public KeyBindingsManager KeyBindings { get; }
    Public ReadOnly Property KeyBindings As KeyBindingsManager
    Property value

    KeyBindingsManager - the customer-facing key bindings manager.

    Example
    // Redirect Ctrl+S to a host-app save handler:

MyEditor.KeyBindings.Override(EditorActionId.Save, () => SaveDocument());



// Disable the built-in Ctrl+P print shortcut:

MyEditor.KeyBindings.Disable(EditorActionId.Print);

    Language

    Sets or returns the UI language of the editor control. Changing this property re-localises toolbar tooltips, dialog labels, context-menu items, and message strings. When SpellCheckOptions.SpellCheckLanguage is set to SameAsEditorLanguage (the default) the spell-checker language follows this property automatically.

    Syntax
    public EditorLanguage Language { get; set; }
    Public Property Language As EditorLanguage
    Property value

    EditorLanguage - defaults to EditorLanguage.EnglishUs.

    Remarks

    Backed by the dependency property LanguageProperty.

    Example
    MyEditor.Language = EditorLanguage.German;

    LicenseKey

    Sets or returns the license key applied to all instances of WpfHtmlEditor created by the host application. Assign this once at application startup (typically in App.xaml.cs) before any editor instance is constructed.

    Syntax
    public static string LicenseKey { get; set; }
    Public Shared Property LicenseKey As String
    Property value

    string - the license-key string.

    Example
    // In App.xaml.cs OnStartup, before any Window is shown:

WpfHtmlEditor.LicenseKey = "your-license-key-here";

    Options

    Returns (or replaces) the aggregate option object holding behavior flags such as EnterKeyResponse, AutoDetectWordPaste, AutoResizeLargeImages, MaxPastedImageWidth, EnableTableCellMerge, ConvertAbsoluteUrlsToRelativeUrls, UrlEncodeHyperlinkHRefs, DefaultHtmlType, ShowZeroBorderGuideline, FooterTagNavigatorTextColor, and FooterTagNavigatorFontInfo.

    Syntax
    public UserOption Options { get; set; }
    Public Property Options As UserOption
    Property value

    UserOption - the editor's user-options bag. See the UserOption reference for the full list of sub-properties.

    Example
    MyEditor.Options.AutoDetectWordPaste = true;
MyEditor.Options.MaxPastedImageWidth = 720;
MyEditor.Options.EnterKeyResponse = EnterKeyResponses.NewParagraph;
    MyEditor.Options.AutoDetectWordPaste = True
MyEditor.Options.MaxPastedImageWidth = 720
MyEditor.Options.EnterKeyResponse = EnterKeyResponses.NewParagraph

    ProductVersion

    Returns the assembly version of the control. Useful for logging, telemetry, or showing a version banner in the host application's About dialog.

    Syntax
    public string ProductVersion { get; }
    Public ReadOnly Property ProductVersion As String
    Property value

    string - the product version string, e.g. "9.0.14.0".

    Example
    LblAbout.Content = $"SpiceLogic HTML Editor v{MyEditor.ProductVersion}";

    ScrollBarSetting

    Sets or returns the visibility of the editor's scroll bars. In EditorModes.HtmlEdit the property is fixed at ScrollBarVisibility.Auto and writes are ignored.

    Syntax
    public ScrollBarVisibility ScrollBarSetting { get; set; }
    Public Property ScrollBarSetting As ScrollBarVisibility
    Property value

    SpiceLogic.HtmlEditor.Abstractions.ScrollBarVisibility - one of Default, Visible, Hidden, or Auto.

    Example
    MyEditor.ScrollBarSetting = ScrollBarVisibility.Auto;

    ScrollRectangle

    Returns the rectangle representing the editor's scrollable region in pixels. Useful when implementing custom scroll-driven behaviors such as floating UI on top of the editor.

    Syntax
    public System.Drawing.Rectangle ScrollRectangle { get; }
    Public ReadOnly Property ScrollRectangle As System.Drawing.Rectangle
    Property value

    System.Drawing.Rectangle - the scrollable region.

    Example
    var rect = MyEditor.ScrollRectangle;
System.Diagnostics.Debug.WriteLine($"Document body is {rect.Width} x {rect.Height} pixels");
    Dim rect = MyEditor.ScrollRectangle
System.Diagnostics.Debug.WriteLine($"Document body is {rect.Width} x {rect.Height} pixels")

    Selection

    Returns the selection service used to read, set, and manipulate the current text selection inside the editor.

    Syntax
    public ISelectionService Selection { get; set; }
    Public Property Selection As ISelectionService
    Property value

    ISelectionService - the selection service.

    Example
    string selected = MyEditor.Selection.GetSelectedHtml();
if (!string.IsNullOrEmpty(selected))
    System.Windows.MessageBox.Show(selected);
    Dim selected As String = MyEditor.Selection.GetSelectedHtml()
If Not String.IsNullOrEmpty(selected) Then System.Windows.MessageBox.Show(selected)

    SpellCheckOptions

    Returns (or replaces) the spell-checker option object. The object holds the dictionary language, the dictionary-location strategy, and toggle flags such as inline-on-type and ignore-uppercase.

    Syntax
    public SpellCheckerOption SpellCheckOptions { get; set; }
    Public Property SpellCheckOptions As SpellCheckerOption
    Property value

    SpellCheckerOption - the spell-checker options.

    Example
    MyEditor.SpellCheckOptions.SpellCheckLanguage = SpellCheckLanguages.SameAsEditorLanguage;
MyEditor.SpellCheckOptions.IgnoreDigits = true;
    MyEditor.SpellCheckOptions.SpellCheckLanguage = SpellCheckLanguages.SameAsEditorLanguage
MyEditor.SpellCheckOptions.IgnoreDigits = True

    StateQuery

    Returns the state-query service used to ask the editor questions about the current selection (is bold on? is the caret in a list?). Toolbar synchronisation and custom UI overlays use this service.

    Syntax
    public IStateQueryService StateQuery { get; set; }
    Public Property StateQuery As IStateQueryService
    Property value

    IStateQueryService - the state-query service.

    Example
    // Sync a host toolbar button's IsChecked state with the editor:

BtnBold.IsChecked = MyEditor.StateQuery.IsBold();

    Toolbar1

    Returns the first (upper) factory toolbar instance. Use this to add, remove, or reorder toolbar buttons programmatically.

    Syntax
    public FirstToolbar Toolbar1 { get; }
    Public ReadOnly Property Toolbar1 As FirstToolbar
    Property value

    FirstToolbar - the first toolbar.

    Example
    // Hide the entire top toolbar for a chrome-less embedded view:

MyEditor.Toolbar1.Visibility = System.Windows.Visibility.Collapsed;

    Toolbar2

    Returns the second (lower) factory toolbar instance.

    Syntax
    public SecondToolbar Toolbar2 { get; }
    Public ReadOnly Property Toolbar2 As SecondToolbar
    Property value

    SecondToolbar - the second toolbar.

    Example
    MyEditor.Toolbar2.Visibility = System.Windows.Visibility.Collapsed;

    ToolbarFooter

    Returns the footer toolbar (tag navigator and mode-switch buttons).

    Syntax
    public FooterToolbar ToolbarFooter { get; }
    Public ReadOnly Property ToolbarFooter As FooterToolbar
    Property value

    FooterToolbar - the footer toolbar.

    Example
    // Force-hide the footer for a kiosk-mode window:

MyEditor.ToolbarFooter.Visibility = System.Windows.Visibility.Collapsed;

    Toolbar1Items

    Returns the live ItemCollection of additional items shown on Toolbar1. Add WPF controls (Button, Separator, custom UserControl) to this collection in XAML or code to extend the toolbar.

    Syntax
    public ItemCollection Toolbar1Items { get; }
    Public ReadOnly Property Toolbar1Items As ItemCollection
    Property value

    ItemCollection - additional Toolbar1 items.

    Example
    var btn = new System.Windows.Controls.Button
{
    Content = "Insert Date"
};
btn.Click += (s, e) => MyEditor.Content.InsertHtml(DateTime.Today.ToShortDateString());
MyEditor.Toolbar1Items.Add(btn);
        Dim btn = New System.Windows.Controls.Button With {
.Content = "Insert Date"
    }
    btn.Click += Function(s, e) MyEditor.Content.InsertHtml(DateTime.Today.ToShortDateString())
    MyEditor.Toolbar1Items.Add(btn)

    Toolbar1ItemsSource

    Sets or returns an enumerable bound as ItemsSource for the Toolbar1 extension area. Use this when you want to drive the toolbar from a view-model.

    Syntax
    public IEnumerable Toolbar1ItemsSource { get; set; }
    Public Property Toolbar1ItemsSource As IEnumerable
    Property value

    IEnumerable - the items source.

    Remarks

    Backed by the dependency property Toolbar1ItemsSourceProperty.

    Example
    // In XAML:

// <wpf:WpfHtmlEditor Toolbar1ItemsSource="{Binding ExtraToolbarItems}" />



// Or in code:

MyEditor.Toolbar1ItemsSource = ViewModel.ExtraToolbarItems;

    Toolbar2Items

    Returns the live ItemCollection of additional items shown on Toolbar2.

    Syntax
    public ItemCollection Toolbar2Items { get; }
    Public ReadOnly Property Toolbar2Items As ItemCollection
    Property value

    ItemCollection - additional Toolbar2 items.

    Example
    MyEditor.Toolbar2Items.Add(new System.Windows.Controls.Separator());
MyEditor.Toolbar2Items.Add(new System.Windows.Controls.Button { Content = "Custom" });
    MyEditor.Toolbar2Items.Add(New System.Windows.Controls.Separator())
MyEditor.Toolbar2Items.Add(New System.Windows.Controls.Button With {
    .Content = "Custom"
})

    Toolbar2ItemsSource

    Sets or returns an enumerable bound as ItemsSource for the Toolbar2 extension area.

    Syntax
    public IEnumerable Toolbar2ItemsSource { get; set; }
    Public Property Toolbar2ItemsSource As IEnumerable
    Property value

    IEnumerable - the items source.

    Remarks

    Backed by the dependency property Toolbar2ItemsSourceProperty.

    Example
    MyEditor.Toolbar2ItemsSource = ViewModel.SecondaryToolbarItems;

    ToolbarContextMenuStrip

    Sets or returns the WPF ContextMenu used when the user right-clicks on the toolbar strips. To set a context menu for the editing surface, use EditorContextMenuStrip instead.

    Syntax
    public System.Windows.Controls.ContextMenu ToolbarContextMenuStrip { get; set; }
    Public Property ToolbarContextMenuStrip As System.Windows.Controls.ContextMenu
    Property value

    ContextMenu - toolbar context menu, or null to clear.

    Example
    var menu = new System.Windows.Controls.ContextMenu();
var item = new System.Windows.Controls.MenuItem
{
    Header = "Hide Toolbar"
};
item.Click += (s, e) => MyEditor.Toolbar1.Visibility = System.Windows.Visibility.Collapsed;
menu.Items.Add(item);
MyEditor.ToolbarContextMenuStrip = menu;
        Dim menu = New System.Windows.Controls.ContextMenu()
    Dim item = New System.Windows.Controls.MenuItem With {
.Header = "Hide Toolbar"
    }
    item.Click += Function(s, e) CSharpImpl.__Assign(MyEditor.Toolbar1.Visibility, System.Windows.Visibility.Collapsed)
    menu.Items.Add(item)
    MyEditor.ToolbarContextMenuStrip = menu

    ToolbarItemOverrider

    Returns the helper used to override the click behavior of any built-in factory toolbar button (Save, Open, Bold, Insert Image, etc.). Each built-in button exposes a corresponding override method; subscribe to redirect clicks to a host-app handler.

    Syntax
    public ToolbarItemOverrideHelper ToolbarItemOverrider { get; }
    Public ReadOnly Property ToolbarItemOverrider As ToolbarItemOverrideHelper
    Property value

    ToolbarItemOverrideHelper - the override helper.

    Example
    // Replace the built-in Save handler with a host-app implementation:
MyEditor.ToolbarItemOverrider.OnSaveButtonClick += (s, e) =>
{
    e.Handled = true;
    MyDocumentRepository.Save(MyEditor.DocumentHtml);
};
    ' Replace the built-in Save handler with a host-app implementation:
MyEditor.ToolbarItemOverrider.OnSaveButtonClick += Sub(s, e)
                                                       e.Handled = True
                                                       MyDocumentRepository.Save(MyEditor.DocumentHtml)

    VerticalScrollPosition

    Returns the editor's current vertical scroll position in pixels. Always returns 0 when the editor is in HTML-source mode.

    Syntax
    public int VerticalScrollPosition { get; }
    Public ReadOnly Property VerticalScrollPosition As Integer
    Property value

    int - vertical scroll offset in pixels.

    Example
    int y = MyEditor.VerticalScrollPosition;
LblStatus.Content = $"Scrolled {y}px from the top";
    Dim y As Integer = MyEditor.VerticalScrollPosition
LblStatus.Content = $"Scrolled {y}px from the top"

    WordWrap

    Sets or returns whether long lines automatically wrap at the editor's right margin. When false, whitespace collapses as for white-space: nowrap and lines extend horizontally until a manual line break.

    Syntax
    public bool WordWrap { get; set; }
    Public Property WordWrap As Boolean
    Property value

    bool - true (the default) to word-wrap lines; false to suppress wrapping.

    Example
    // Long lines should scroll horizontally instead of wrapping:
MyEditor.WordWrap = false;
    ' Long lines should scroll horizontally instead of wrapping:
MyEditor.WordWrap = False

    Last updated on May 14, 2026