One of the problems I faced while using ScintillaNet control is… properly setting font for the control. Why is that so important? Although my app is not multicultural, I want it to allow people use all diacritical characters in the language of their choice. Using standard TextBox control you just change font in a couple of lines:

FontDialog fd = new FontDialog();
fd.FontMustExist = true;
if (fd.ShowDialog(this) == DialogResult.OK)
{
    this.textBox1.Font = fd.Font;
}

This is pretty easy, right? The only interesting thing here is that even if you do not specify a proper “Script” (what specific version of the font you want to use: Western, Greek, Turkish, Baltic, Central European, Cyrillic, Vietnamese) you will be able to use diacritical character for the language of your choice (if you do not believe me – check it!).

ScintillaNET Control behaves different. If you do not specify explicitly additional options regarding character encoding – diacritical characters will not be available for use in that control. It is important to notice, that there is special option (I mentioned above) connected with character encoding in FontDialog available in System.Windows.Forms namespace:

Picture 1. Standard .NET FontDialog

Notice that below textbox that present how will actual setting affect font outlook, there is an option entitled “Script” – this one is used to use a proper “character set” of chosen font. If you want to – for example – use some Slavic diacritical characters you should choose “Central European” instead of “Western”.

But even if you do so, you still will not be able to use diacritical characters in ScintillaNET Control. What is the problem, then? There are two problems to be precise:

1. if you use application settings to store your font (and I do) than you must be aware, that the font that you load through Application Settings may not be exactly the same as the font you saved. You need to create a proper font from the font stored in application settings.
2. after creating font that will have properly set information about code page, you need to set encoding in ScintillaNET Control, and activate the font.

You may wonder, how is that possible that font loaded from application settings differs from the one that was stored in application settings – the problem is that information about GDI character set is not being stored. So, if the font you have selected had GDI character set set to any value other than default – the value is being lost at the moment of saving font in application settings. You may overcome this problem, storing GDI character set for the specified font. Next thing, you should do, after loading font from application settings is to set its GDICharSet property, so the font will be exactly the same as the one that was saved. Unfortunatelly, GDICharSet property is read-only, so there is no single-line solution for this problem. First solution that came up to my mind was to use LOGFONT structure to create a font that will have properly set its GDICharSet. To do this, you need to create a definition for the LOGFONT structure:

using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential)]
public class LOGFONT
{
    public const int LF_FACESIZE = 32;
    public int lfHeight;
    public int lfWidth;
    public int lfEscapement;
    public int lfOrientation;
    public int lfWeight;
    public byte lfItalic;
    public byte lfUnderline;
    public byte lfStrikeOut;
    public byte lfCharSet;
    public byte lfOutPrecision;
    public byte lfClipPrecision;
    public byte lfQuality;
    public byte lfPitchAndFamily;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = LF_FACESIZE)]
    public string lfFaceName;
}

a sample function that creates font that will have properly set GDICharSet property could look like this:

private Font CreateFont(Font f, byte gdicharset)
{
    LOGFONT logfont = new LOGFONT();
    logfont.lfFaceName = f.Name;
    logfont.lfHeight = f.Height;
    logfont.lfCharSet = gdicharset;

    return Font.FromLogFont(logfont);
}

It is quite easy, right? But… it could be even easier :) If you look closely to all the Font constructors, you’ll notice, that there is one, that takes GDICharSet as an argument – this is just the thing you’ll need. The whole 5-line long function presented above could then be replaced by a single line of code (that does exactly the same):

Font f = new Font(defaultfont.FontFamily, defaultfont.Size, defaultfont.Style, defaultfont.Unit, gdicharset);

And of course, you do not have to define LOGFONT anymore ;) Ok, so now the font has the GDICharSet properly set. If you want the control to be able to use diacritical characters, you have to set some of its properties. I have spent quite some time to figure it out which properties should be set, and discovered that even the order of setting properties is important! So, to save you some time, I’ll just paste the code I use to properly initialize ScintillaNET Control in my application:

ScintillaNet.CharacterSet charset = (ScintillaNet.CharacterSet)gdicharset;
this.content.Styles.Default.CharacterSet = charset;
Font f = new Font(defaultfont.FontFamily, defaultfont.Size, defaultfont.Style, defaultfont.Unit, gdicharset);
this.content.Styles.Default.Font = f;
this.content.UseFont = true;
this.content.Encoding = System.Text.Encoding.GetEncoding(encodingName);

So that’s it. I really recommend using ScintillaNET Control – it is feature rich and free. It lacks up to date documentation and recently its development seems to be frozen, but it may be a good thing to take a look at it before deciding to develop your own TextBoxWithALotOfFeatures control :)