class TextStyle
{
public:
    COLORREF fgColor;
    COLORREF bgColor;    
    HFONT    font;
public:
    TextStyle(): fgColor(CLR_INVALID), bgColor(CLR_INVALID), font(0) {}
};

class IDecoratorListener;
class IDecoratedSubstring;

class IDecorator
{
public:
    virtual ~IDecorator() {}
public:
    virtual void
    decorate(
        unsigned            line, 
        const char_type*    str,
        unsigned            len, 
        IDecoratorListener& dl) const = 0;
};

class IDecoratorListener
{
public:
    virtual ~IDecoratorListener() {}
public:
    virtual bool
    onSubstringDecorated(
        unsigned                    line, 
        const char_type*            str,
        unsigned                    strLen, 
        const char_type*            substr,
        unsigned                    substrLen, 
        const TextStyle&            ts) = 0;

    virtual bool
    onSubstringDecorated(
        unsigned                    line,
        const char_type*            str,
        unsigned                    strLen, 
        const char_type*            substr,
        unsigned                    substrLen, 
        const IDecoratedSubstring&  ds) = 0;
};

class IDecoratedSubstring
{
public:
    virtual ~IDecoratedSubstring() {}
public:
    virtual unsigned 
    getWidth(unsigned width) const = 0;

    virtual unsigned 
    getHeight(unsigned height) const = 0;

    virtual FONT
    getFont() const = 0;

    virtual void
    paint(HDC g, unsigned width, unsigned height) const = 0;
};

class FontChangeDecorator : public IDecorator, IDecoratorListener
{
    IDecorator*         decorator_;
    IDecoratorListener* listener_;
public:
    FontChangeDecorator(IDecorator* decorator): decorator_(decorator) {}
public:
    virtual void
    decorate(
        unsigned            line, 
        const char_type*    str,
        unsigned            len, 
        IDecoratorListener& dl) const
    {
        // запомнить текущее значение listener_, чтобы восстановить его в случае рекурсивного 
        // вызова FontChangeDecorator::decorate
        IDecoratorListener* l = listener_;
        // подменить листенер
        listener_ = dl;        
        decorator_->decorate(line, str, len, *this);
        // восстановить листенер 
        listener_ = l;
    }
private:
    virtual bool
    onSubstringDecorated(
        unsigned         line, 
        const char_type* str,
        unsigned         strLen, 
        const char_type* substr,
        unsigned         substrLen, 
        const TextStyle& ts)
    {
        HDC dc = getTempDC(); // каким-то образом получить HDC
        ::SelectFont(dc, ts.font);
        TEXTMETRICS tm;
        ::GetTextMetrics(dc, &tm);
        LOGFONT lf = textMetrics2LogFont(tm);  // как-то сконвертировали
        lf.height += (lf.height * 10) / 100; // увеличить шрифт на 10%
        
        TextStyle newTs(ts);
        newTs.font = ::CreateFontIndirect(lf);

        // передать в листенер измененный шрифт
        listener_.onSubstringDecorated(line, str, strLen, substr, substrLen, newTs);
    }
};

void
setFontChangeDecorator(HWND hwnd /* хендл на окно моего редактора */)
{
    IDecorator* d  = ::SendMessage(hwnd, MYEDITOR_MSG_GETDECORATOR, 0, 0);
    IDecorator* d2 = new FontChangeDecorator(d);

   ::SendMessage(hwnd, MYEDITOR_MSG_SETDECORATOR, d2, 0)
}

A>Вернее чтобы упростить реализацию этих функций

A>class IDecoratorListener
A>{
A>public:
A>    virtual ~IDecoratorListener() {}
A>public:
A>    virtual bool
A>    onSubstringDecorated(
A>        unsigned                    line, 
A>        const char_type*            str,
A>        unsigned                    strLen, 
A>        const char_type*            substr,
A>        unsigned                    substrLen, 
A>        const TextStyle&            ts) = 0;

A>    virtual bool
A>    onSubstringDecorated(
A>        unsigned                    line,
A>        const char_type*            str,
A>        unsigned                    strLen, 
A>        const char_type*            substr,
A>        unsigned                    substrLen, 
A>        const IDecoratedSubstring&  ds) = 0;
A>};

A>...
A>    virtual bool
A>    onSubstringDecorated(
A>        unsigned         line, 
A>        const char_type* str,
A>        unsigned         strLen, 
A>        const char_type* substr,
A>        unsigned         substrLen, 
A>        const TextStyle& ts)
A>    {
A>        HDC dc = getTempDC(); // каким-то образом получить HDC
A>        ::SelectFont(dc, ts.font);
A>        TEXTMETRICS tm;
A>        ::GetTextMetrics(dc, &tm);
A>        LOGFONT lf = textMetrics2LogFont(tm);  // как-то сконвертировали
A>        lf.height += (lf.height * 10) / 100; // увеличить шрифт на 10%
        
A>        TextStyle newTs(ts);
A>        newTs.font = ::CreateFontIndirect(lf);

A>        // передать в листенер измененный шрифт
A>        listener_.onSubstringDecorated(line, str, strLen, substr, substrLen, newTs);
A>    }
A>};
A>

A>3. Визуализация текста не ограничена рисованием текста или рисованием картинки вместо текста, т.к. реализация IDecoratedSubstring ограничена только фантазией юзверя (в разумных пределах конечно ;

class Document
{
    string[] lines;
public:
    string getLine(int idx) { return lines[idx]; }
};

VD>Да уж... Прямо как в ИЕ или Сцинтиле... почти! Так как динамическое пересоздание шрифта на каждый токен — это задница для производительности. На относительно старом железе это будет тормозить как АБС.

A>>3. Визуализация текста не ограничена рисованием текста или рисованием картинки вместо текста, т.к. реализация IDecoratedSubstring ограничена только фантазией юзверя (в разумных пределах конечно ;

using (FreezeEventHelper herper = new FreezeEventHelper(this))
{
  Document.ResetViewsInfo();

  Items.Clear();
  
  foreach (string line in Parse(text))
    Items.Add(new DocumentRow(line));

  Document.Formatter.PrepareRows(this);
}

cacheSize = numberOfVisibleLines;
onLinesDeleted(int startLine, int count)
{
  if(count > cacheSize)
  {
    clearCache();
  }
  else
  {  // в цикле перебрать все удаленные строки и если для них есть записи в кэше, то удалить их из кэша     
  }
}

if (startPosition > endPosition)
    Utils.Swap(ref startPosition, ref endPosition);

DocumentRow row = new DocumentRow(
    Rows[startPosition.Line].Text.Substring(0, startPosition.Character)
    + Rows[endPosition.Line].Text.Substring(endPosition.Character));

row.StartStylerState = Rows[startPosition.Line].StartStylerState;

Rows.RemoveRange(startPosition.Line, endPosition.Line - startPosition.Line + 1);
Rows.Insert(startPosition.Line, row);

1. arr[] = { 'm', 's', 'd', 'n' }
2. arr[] = { 's', 'd', 'n' }
3. arr[] = { 'r', 's', 'd', 'n' }

1. arr[] = { 'm', 's', 'd', 'n' }
2. arr[] = { '\0', 's', 'd', 'n' }
3. arr[] = { 'r', 's', 'd', 'n' }

ВВ>1. arr[] = { 'm', 's', 'd', 'n' }
ВВ>2. arr[] = { 's', 'd', 'n' }
ВВ>3. arr[] = { 'r', 's', 'd', 'n' }
ВВ>

ВВ>1. arr[] = { 'm', 's', 'd', 'n' }
ВВ>2. arr[] = { '\0', 's', 'd', 'n' }
ВВ>3. arr[] = { 'r', 's', 'd', 'n' }
ВВ>

bool IsDirty { get; set; }
string Text { get; set; }
void Replace(
    string text, 
    Position<Document> start, 
    Position<Document> end);
void Delete(Position<Document> start, Position<Document> end)
bool CanUndo { get; }
bool CanRedo { get; }
void Undo();
void Redo();
string GetText(
    Position<Document> startPosition, 
    Position<Document> endPosition);

Command - абстрактный
    MultiCommand
    ModifyTextCommand - абстрактный
        InsertCommand 
        DeleteCommand
        UpdateCommand

ВВ>В общем мое скромное мнение на настоящий момент — то, что ты немножко с абстракциями переборщил. Прошу не кидать тухлыми помидорами...

VD>Что тут вообще нужно изучать? По-моему, все и без объяснения понятно. А учитывая, что каждый метод/свойство еще собжены коментариями...

VD>Command - абстрактный
VD>    MultiCommand
VD>    ModifyTextCommand - абстрактный
VD>        InsertCommand 
VD>        DeleteCommand
VD>        UpdateCommand
VD>

SCI_GETENDSTYLED
SCI_STARTSTYLING(int position, int mask)
SCI_SETSTYLING(int length, int style)
SCI_SETSTYLINGEX(int length, const char *styles)
SCI_SETLINESTATE(int line, int value)
SCI_GETLINESTATE(int line)
SCI_GETMAXLINESTATE

A gap buffer is a structure that models a string but allows relatively
efficient insertion of text somewhere in the middle.

ВВ>А память

VD>>Command - абстрактный
VD>>    MultiCommand
VD>>    ModifyTextCommand - абстрактный
VD>>        InsertCommand 
VD>>        DeleteCommand
VD>>        UpdateCommand
VD>>

ВВ>А зачем?

ВВ>SCI_GETENDSTYLED
ВВ>SCI_STARTSTYLING(int position, int mask)
ВВ>SCI_SETSTYLING(int length, int style)
ВВ>SCI_SETSTYLINGEX(int length, const char *styles)
ВВ>SCI_SETLINESTATE(int line, int value)
ВВ>SCI_GETLINESTATE(int line)
ВВ>SCI_GETMAXLINESTATE
ВВ>

ВВ>А вот в работу со стилями у тебя я до сих пор до конца не въеду. Почем бы это? Может, последствия "тяжелых" новогодних праздников?

int StartStylerState { get; set; }
AppliedStyle[] AppliedStyles { get; set; }

ВВ>ОК, я понял. "Мне кажется странным, что работа со строками ведется в лоб, а не используется какой-либо из алгоритмов, позволяющих эффективно модифицировать строки". Так лучше?

ВВ>А чем отличается "низкоуровневая абстракция" char* от System.String? Наличием звездочки?

void StartParse(DocumentRowCollection rows, int startState);
void PrepareRows(DocumentRowCollection rows);
int PrepareRows(DocumentRowCollection rows, int start, int count);

void ExecuteCommand(ICommand command);

VD>>Возможно отчасти потому, что Сцинтиле много лет и всей все уже отработно, а у меня работа со стилями откровенно не доделана.

ВВ>Вот, было подозрение И наверное лучше сначала доделать.

class StringTable
{
    private readonly ArrayList Buckets = new ArrayList();
    private Bucket lastBucket;
    private int lastOffset = -1;
    
    public StringTable()
    {
        
    }

    public void Add(string value)
    {
        if (value == null || value.Length == 0)
            throw new ArgumentException();
            
        InternalAdd(value, 0, Buckets);
    }
    
    
    private void InternalAdd(string value, int offset, ArrayList buckets)
    {
        char c = value[offset];
        
        foreach (Bucket b in buckets)
            if (b.Char == c)
            { 
                if (offset == 2 || value.Length == offset + 1)
                    b.Strings.Add(value);
                else
                    InternalAdd(value, offset++, b.Buckets);    
                
                return;
            }
        
        Bucket newBuck = new Bucket(c);
        buckets.Add(newBuck);
        
        if (offset == 2 || value.Length == offset + 1)
            newBuck.Strings.Add(value);
        else
            InternalAdd(value, offset++, newBuck.Buckets);
    }
    
    
    public bool FindSegment(char c)
    {    
        if (++lastOffset < 2)
        {
            foreach (Bucket b in lastBucket == null ? Buckets : lastBucket.Buckets)
                if (b.Char == c)
                {
                    lastBucket = b;
                    return true;
                }
        }
        else
            foreach (string s in lastBucket.Strings)
                if (s.Length >= lastOffset + 1 && s[lastOffset] == c)
                    return true;
    
        return false;
    }
    
    public void ResetSearch()
    {
        lastBucket = null;
        lastOffset = -1;
    }
}


class Bucket
{
    public readonly char Char;
    public readonly ArrayList Buckets = new ArrayList();
    public readonly StringCollection Strings = new StringCollection();
    
    public Bucket(char c)
    {
        Char = c;
    }    
}

Console.WriteLine(table.FindSegment('i'));
Console.WriteLine(table.FindSegment('f'));
Console.WriteLine(table.FindSegment('f'));

True
True
False

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

using CharMap = System.Collections.Generic.Dictionary<char, 
    System.Collections.Generic.List<string>>;

class Program
{
    static string _strs = 
        "using assembly event field method param property return "
        + "type typevar namespace void where class struct new partial "
        + "interface enum delegate base this ref out __arglist params "
        + "public protected internal private unsafe abstract sealed "
        + "static object string sbyte byte short ushort int uint "
        + "long ulong char extern override readonly virtual volatile const "
        + "implicit explicit operator add remove float double decimal "
        + "bool get set true false is as stackalloc checked unchecked "
        + "if else switch while do for foreach in break continue yield "
        + "throw lock fixed case default null typeof sizeof try finally "
        + "catch goto";

    static void Main(string[] args)
    {
        File.WriteAllText(@"..\..\dfa.cs", Make.Dfa(_strs.Split(' ')));
    }
}

class Make
{
    public static string Dfa(string[] strs)
    {
        StringBuilder str = new StringBuilder(1024);

        // Сортировка не обязательна. Просто так получается более читабельный код.
        Array.Sort(strs);

        // Генерируем класс с функцией-распознователем.
        // Внутренности функции-распознователя генериуются отдельным методом.
        str.AppendFormat(@"
class Dfa
{{
    public static int CheckStr(string text, int start)
    {{
        {0}

        return -1;
    }}
}}
", MakeLevel(strs, 2));

        return str.ToString();
    }

    /// <summary>
    /// Рекурсивная функция генерирующая распознования одного уровня символов.
    /// </summary>
    /// <param name="strs">Набор строк для которых нужно сгенерировать распознование
    /// </param>
    /// <param name="level">Уровень вложенности. Используется как для корректноой
    /// генерации отступов, так и для рассчета длинны строк.</param>
    /// <returns></returns>
    private static string MakeLevel(string[] strs, int level)
    {
        StringBuilder str = new StringBuilder(1024);
        CharMap charMap = MakeDic(strs);

        // Генерируем проверку выхода за конец строки и switch для данного уровня.
        str.Append(
@"
if (start > text.Length)
    return -1;

switch(text[start])
{
");
        foreach (KeyValuePair<char, List<string>> pair in charMap)
        {
            str.AppendFormat(
@"    case '{0}':
    {{
", pair.Key);

            // Удаляем у всех строк в списке первый символ (мы ведь его уже 
            // обработали). При этом если строка пустая, то она удаляется из списка.
            string[] nextStrs = RemoveFirstChars(pair.Value);

            // Опримизации код с целью сократить его объем.
            if (nextStrs.Length == 1) // если остался один альтернатива?...
            {
                string ident = nextStrs[0];
                
                if (ident.Length == 1) // если осталось проверить один символ строки...
                {
                    // Генерируем проверку одного символа строки. Если она не удачна,
                    // то или возвращаем -1 (строка не распознана), или длинну строки,
                    // если nextStrs.Length != pair.Value.Count.
                    // Условие nextStrs.Length != pair.Value.Count выполняется если
                    // на этом уровне есть строки являющиеся полной подстрокой для днугих
                    // строк. Например, "test" является полной подстрокой для "test1".
                    str.AppendFormat(
@"        return ++start < text.Length && text[start] == '{0}' ? {1} : {2};
", ident[0], level, nextStrs.Length != pair.Value.Count ? level - 1 : -1);
                }
                else
                {
                    // подстрока одна, но символов в ней много...
                    // используем для проверки функцию string.Compare().
                    str.AppendFormat(
@"        return string.Compare(text, start + 1, ""{0}"", 0, {1}) == 0
            ? {2} : -1;
", ident, ident.Length, level + ident.Length - 1);
                }
            }
            else if (nextStrs.Length > 0)
            {
                // Если есть алтернативы, то генерируем вложеный switch.
                // Для этого вызваем эту же функцию рекурсивно.
                str.Append(@"        start++;
");
                str.Append(MakeLevel(nextStrs, level + 1));
                str.Append("        break;");
            }
            else // Мы распознали строку. При этом ее длинна равна level - 1.
                str.AppendFormat("        return {0};", level - 1);

            // Закрываем блок case-а.
            str.Append(
@"
    }
");
        }
        // Закрываем блок switch-а.
        str.Append(@"}");

        // Добавляем отступы.
        str.Replace("\r\n", "\r\n" + new string('\t', level));

        return str.ToString();
    }

    /// <summary>
    /// Удаляет первые символы строк и копирует непустые строки в новый массив.
    /// </summary>
    /// <param name="strs">Исходная коллекция строк.</param>
    static string[] RemoveFirstChars(IList<string> strs)
    {
        List<string> list = new List<string>(strs.Count);

        foreach (string str in strs)
            if (str.Length > 1)
                list.Add(str.Substring(1));

        return list.ToArray();
    }

    /// <summary>
    /// Создает словарь ключем которого является первые символы строк, а 
    /// значением списки строк начинающихся на этот символ.
    /// </summary>
    /// <param name="strs"></param>
    /// <returns></returns>
    private static CharMap MakeDic(string[] strs)
    {
        CharMap map = new CharMap();

        foreach (string str in strs)
        {
            List<string> list;
            if (!map.TryGetValue(str[0], out list))
                map.Add(str[0], list = new List<string>());

            list.Add(str);
        }

        return map;
    }
}

using System;

class Program
{
    static void Check(string text, int start)
    {
        int ret = Dfa.CheckStr(text, start);
        if (ret >= 0)
            Console.WriteLine("В строке '{0}' распознано ключевое слово '{1}'",
                text, text.Substring(start, ret));
        else
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("В строке '{0}' нераспознано ключевых слово", text);
            Console.ResetColor();
        }
    }

    static void Main(string[] args)
    {
        Check(" test", 1);
        Check(" test1", 1);
        Check(" case", 1);
        Check(" az", 1);
        Check(" as", 1);
        Check(" absract", 1);
        Check(" abstract", 1);
        Check(" abstrac", 1);

        Console.ReadLine();
    }
}