void some_class_t::receive_event( event_t event )
    {
        if( state_one == current_state() )
            {
                if( event_one == event )
                    do_something();
                else if( event_two == event )
                    switch_state( state_two );
                ...
            }
        else if( state_two == current_state() )
            { ... }
        ...
    }

void some_class_t::receive_event( event_t event )
    {
        (this->*m_state_handler)( event );
    }
void some_class_t::state_one_handler( event_t event )
    {
        if( event_one == event )
            do_something();
        else if( event_two == event )
            // Для переключения состояния просто меняем указатель на текущий обработчик.
            m_state_handler = &some_class_t::state_two_handler;
    }

template<typename FuncT>
struct Functor;

template<typename ObjT, typename FuncT>
struct Delegate;

template<> struct Functor<void()> { virtual void operator()()=0; };

template<typename ObjT> 
struct Delegate<ObjT, void()> : Functor<void()>{
    Delegate(ObjT* obj_, (ObjT::*func_)()) : obj(obj_), func(func_) {}

    virtual void operator()() { (obj->*func)(); }
protected:
    ObjT*   obj;
    MemberFuncT func;
};

template<> struct Functor<typename ParamT1> { virtual void operator()(ParamT1)=0; };

template<typename ObjT, typename ParamT1> 
struct Delegate<ObjT, void(ParamT1)> : Functor<void(ParamT1)> {
    Delegate(ObjT* obj_, (ObjT::*func_)(ParamT1)) : obj(obj_), func(func_) {}

    virtual void operator()(ParamT1 p1) { (obj->*func)(p1); }
protected:
    ObjT*   obj;
    MemberFuncT func;
};

// и т.д.

typedef void MyDelegate(char *s); // почти как в C# :)

struct MyStruct {
    Functor<MyDelegate>* callback;
    void Fire() { (*callback)("Hello!"); }
};

class MyHandler {
[...]

  void Method1() {
     MyStruct s1;
     s1.callback = new Delegate<MyHandler, MyDelegate>(this, &HandlerMethod);
     s1.Fire();
  }

  void HandlerMethod(char* s) { std::cout << s; }

};

delegate void MyEventHandler(int eventId);

class some_class
{
    public some_class() { _eventHandler = state_one_handler; }
    
    MyEventHandler _eventHandler;

    void receive_event(int eventId)
    {
        _eventHandler(eventId);
    }

    void state_one_handler(int eventId)
    {
        if (eventId == 1)
                do_something();
        else if (eventId == 2)
                // Для переключения состояния просто меняем указатель на текущий обработчик.
                _eventHandler = state_two_handler;
    }

    void state_two_handler(int eventId)
    {
        // ...
    }

    void do_something() { }
}

// Костанты-идентификаторы сообщений. Можно надыбать на www.codeproject.com или в winuser.h
const int WM_LBUTTONDOWN   =  0x0201;
const int WM_RBUTTONDOWN   =  0x0204;

// Обработчики сообщений. Атрибутом WinMsg с ними ассоциируются сами сообщения.

[WinMsg(WM_RBUTTONDOWN)]
bool OnRButtonDown(ref Message msg)
{
        BackColor = Color.Blue;
        return true;
}

[WinMsg(WM_LBUTTONDOWN)]
bool OnLButtonDown(ref Message msg)
{
        BackColor = Color.Red;
        return true;
}

/// <summary>
/// Ассоциативный массив ключем котрого является клавиатурное сокращения,
/// а значением обработчик выполняемый при нажатии этого клавиатурного 
/// сокращения.
/// </summary>
private KeyboardShortcutsMap _keyboardMap;

...
// В конструкторе:
_keyboardMap = new KeyboardShortcutsMap(this);

...

    protected override void OnKeyDown(KeyEventArgs e)
    {
        if (e.KeyValue >= 16 && e.KeyValue <= 18) // Alt, Control, Shift
            return;

        // Получаем обработчик ассоциирванный с текущим клавиатурным сокращением.
        KeyboardShortcutsMap.KeyHandler keyDownHandler = _keyboardMap[e.KeyData];

        if (keyDownHandler != null)
        {
            keyDownHandler();
            e.Handled = true;
            e.SuppressKeyPress = true;
        }
        else
            base.OnKeyDown(e);
    }

<?xml version="1.0" encoding="utf-8" ?>
<Shortcuts>
    <!-- Навигация по тексту -->
    <Shortcut Key="Up"                      Action="CaretVirtualLineUp"/>
    <Shortcut Key="Down"                    Action="CaretVirtualLineDown"/>
    <Shortcut Key="Shift | Up"              Action="CaretVirtualLineUpExtend"/>
    <Shortcut Key="Shift | Down"            Action="CaretVirtualLineDownExtend"/>
    <Shortcut Key="Home"                    Action="CaretVirtualLineHome"/>
    <Shortcut Key="End"                     Action="CaretVirtualLineEnd"/>
    <Shortcut Key="Shift | Home"            Action="CaretVirtualLineHomeExtend"/>
    <Shortcut Key="Shift | End"             Action="CaretVirtualLineEndExtend"/>
    <Shortcut Key="Left"                    Action="CaretLeft"/>
    <Shortcut Key="Control | Left"          Action="CaretWordLeft"/>
    <Shortcut Key="Control | Right"         Action="CaretWordRight"/>
    <Shortcut Key="Shift | Control | Left"  Action="CaretWordLeftExtend"/>
    ...
    <!-- Клипборд -->
  <Shortcut Key="Control | C"             Action="Copy"/>
  <Shortcut Key="Control | Insert"        Action="Copy"/>
    <Shortcut Key="Control | V"             Action="Paste"/>
    <Shortcut Key="Shift | Insert"          Action="Paste"/>
    <Shortcut Key="Control | X"             Action="Cut"/>
    <Shortcut Key="Shift | Delete"          Action="Cut"/>
    ...
</Shortcuts>

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.IO;
using System.Diagnostics;
using System.Windows.Forms;
using System.Reflection;

namespace Rsdn.Editor
{
    /// <summary>
    /// Хэлпер-класс считывающий информацию о клавиатурных сокращениях из 
    /// файла настроек или ресурсов и преобразующий его во внутренний словарь.
    /// После инициализации можно пользоваться индексером объекта чтобы
    /// получать делегаты-обработчики клавиатурных событий.
    /// Файл должен называться KeyboardShortcutsMap.xml.
    /// Файл с описанием клавиатурных сокращений может находиться
    /// в каталоге %APPDATA%\Rsdn.Editor иди каталоге где располагаться сборка
    /// в котророй находится элемент управления.
    /// Если файл не найден в одном из этих каталогов, то описание 
    /// клавиатурных сокращений берется из ресурсов.
    /// </summary>
    internal class KeyboardShortcutsMap
    {
        /// <summary>
        /// Тип метода вызываемого при клавиатурном сокращении.
        /// </summary>
        public delegate void KeyHandler();

        const string MapFileName = "KeyboardShortcutsMap.xml";

        public KeyboardShortcutsMap(Control view)
        {
            using (XmlReader reader = OpenReader())
            {
                if (!reader.Read() || reader.Name != "xml")
                    throw new ApplicationException("Неверный формат файла KeyboardShortcutsMap.xml");

                while (reader.Read() && string.IsNullOrEmpty(reader.Name))
                    ;

                if (reader.Name != "Shortcuts")
                    throw new ApplicationException("Неверный формат файла KeyboardShortcutsMap.xml");

                Type keyHandlerType = typeof(KeyHandler);
                object[] args = new object[0];
                StringBuilder errors = new StringBuilder(); // сообщения об ошибках

                while (reader.Read())
                {
                    if (reader.Name == "Shortcut")
                    {
                        string key = null;
                        string action = null;

                        try
                        {
                            key = reader.GetAttribute("Key"); // читаем ключь
                            // читаем имя делегата
                            action = reader.GetAttribute("Action");

                            // Получам клавиатурное сокращение плюс делегат и инициализируем
                            // этими значениями внутренний словарь.
                            SetKeyboardHandler(ParseKeys(key),
                                (KeyHandler)KeyHandler.CreateDelegate(
                                keyHandlerType, view, action, false, true));
                        }
                        catch (Exception ex)
                        {
                            errors.AppendLine("Can't add key '" + key + "' with action '"
                                + action + "'. " + ex.Message);
                        }
                    }
                }

                if (errors.Length > 0)
                    MessageBox.Show(view.FindForm(), 
                        "При считывании файла с клавиатурными сокращениями были обнаружены "
                        + "следующие ошибки: " + Environment.NewLine + errors, Utils.AppName,
                        MessageBoxButtons.OK, MessageBoxIcon.Warning); 
            }
        }

        /// <summary>
        /// Открывает XML-файл содержащий описание клавиатурных сокращений
        /// на чтение.
        /// </summary>
        private static XmlReader OpenReader()
        {
            XmlReader reader;

            string path = Environment.GetFolderPath(
                Environment.SpecialFolder.ApplicationData);

            path = Path.Combine(Path.Combine(path, Utils.AppName), MapFileName);

            // Если файл с клавиатурными настройками существует в папке "Application Data" 
            // (%APPDATA%), или в папке где расположена DLL-а, то читаем настройки из него.
            // Иначе чиатаем настройки из файла сохраненного при компиляции в ресурсах.
            if (File.Exists(path))
                reader = XmlReader.Create(path);
            else if (File.Exists(path = Path.Combine(Utils.GetModulePath(), MapFileName)))
                reader = XmlReader.Create(path);
            else
                reader = XmlReader.Create(new StringReader(
                    Properties.Resources.KeyboardShortcutsMap));
            return reader;
        }

        /// <summary>
        /// Преобразует строку содержащую имена клавишь в Keys.
        /// Имена клавишь могут объеденяться по или (знаком "|").
        /// </summary>
        /// <example>"Shift | Control | Right"</example>
        /// <param name="key">Клавиатурное сокращение в виде строки.</param>
        private static Keys ParseKeys(string key)
        {
            Keys keys;
            // Разбиваем ключь на отдельные значения
            string[] keyStrs = key.Split('|');
            keys = 0;

            foreach (string value in keyStrs)
                keys |= (Keys)Enum.Parse(typeof(Keys), value);
            return keys;
        }

        /// <summary>
        /// Возвращает делегат-обработчик события соотвествующий клавиатурному
        /// сокращению или null.
        /// </summary>
        /// <param name="shortcut">Клавиатурное сокращение.</param>
        /// <returns>Делегат обработчки.</returns>
        public KeyHandler this[Keys shortcut]
        {
            get
            {
                KeyHandler keyHandler;

                if (_kbdMap.TryGetValue(shortcut, out keyHandler))
                    return keyHandler;

                return null;
            }
        }

        /// <summary>
        /// Вспомогательный метод позволяющий пуростить инициализацию _kbdMap.
        /// Ассоциирует клавиатурное сокращение и его обработчик.
        /// </summary>
        /// <param name="keyData">Клавиатурное сокращение.</param>
        /// <param name="keyHandler">Обработчик.</param>
        private void SetKeyboardHandler(Keys keyData, KeyHandler keyHandler)
        {
            if (_kbdMap.ContainsKey(keyData))
                Trace.WriteLine("The keyboard shortcut '" + keyData + "' be found twice.");

            _kbdMap[keyData] = keyHandler;
        }

        /// <summary>
        /// Ассоциативный массив ключем котрого является клавиатурное сокращения,
        /// а значением обработчик выполняемый при нажатии этого клавиатурного 
        /// сокращения.
        /// </summary>
        private Dictionary<Keys, KeyHandler> _kbdMap = 
            new Dictionary<Keys, KeyHandler>();
    }
}

VD>// Костанты-идентификаторы сообщений. Можно надыбать на www.codeproject.com или в winuser.h
VD>const int WM_LBUTTONDOWN   =  0x0201;
VD>const int WM_RBUTTONDOWN   =  0x0204;

VD>// Обработчики сообщений. Атрибутом WinMsg с ними ассоциируются сами сообщения.

VD>[WinMsg(WM_RBUTTONDOWN)]
VD>bool OnRButtonDown(ref Message msg)
VD>{
VD>        BackColor = Color.Blue;
VD>        return true;
VD>}

VD>[WinMsg(WM_LBUTTONDOWN)]
VD>bool OnLButtonDown(ref Message msg)
VD>{
VD>        BackColor = Color.Red;
VD>        return true;
VD>}
VD>

void    OnLButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);
void    OnRButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);
void    OnMouseMove(HWND hwnd, int x, int y, UINT keyFlags);

using namespace cls_2;

class    tag_shortcat_t : public tag_no_value_t
    {
    private :
        tag_scalar_t< std::string >    m_key;
        tag_scalar_t< std::string >    m_action;
        tag_no_value_t    m_ctrl;
        tag_no_value_t    m_alt;
        tag_no_value_t    m_shift;
    public :
        // Формат конструктора диктуется требованиями класса tag_vector_of_tags_t.
        tag_shortcat_t( const char * name, bool is_mandatory )
            :    tag_no_value_t( name, is_mandatory, true )
            ,    m_key( self_tag(), "key", true )
            ,    m_action( self_tag(), "action", true )
            ,    m_ctrl( m_key, "ctrl", false )
            ,    m_alt( m_key, "alt", false )
            ,    m_shift( m_key, "shift", false )
            {}
            
        // Код метода по извлечению значений из m_key, m_action, m_ctrl, m_alt и m_shift по вкусу :)
        shortcat_t query_value() const
        {
            return shortcat_t( m_key.query_value(), m_action.query_value(),
                ( m_ctrl.is_defined() ? VK_CTRL : 0 ) |
                ( m_alt.is_defined() ? VK_ALT : 0 ) |
                ( m_shift.is_defined() ? VK_SHIFT : 0 ) );
        }
    };

|| Навигация по тексту
{shortcat {key "Up"}                    {action "CaretVirtualLineUp"}}
{shortcat {key "Down"}                  {action "CaretVirtualLineDown"}}
{shortcat {key {shirt} "Up"}            {action "CaretVirtualLineUpExtend"}}
{shortcat {key {shift} "Down"}          {action "CaretVirtualLineDownExtend"}}
{shortcat {key "Home"}                  {action "CaretVirtualLineHome"}}
{shortcat {key "End"}                   {action "CaretVirtualLineEnd"}}
{shortcat {key {shift} "Home"}          {action "CaretVirtualLineHomeExtend"}}
{shortcat {key {shift} "End"}           {action "CaretVirtualLineEndExtend"}}
{shortcat {key "Left"}                  {action "CaretLeft"}}
{shortcat {key {ctrl} "Left"}           {action "CaretWordLeft"}}
{shortcat {key {ctrl} "Right"}          {action "CaretWordRight"}}
{shortcat {key {shirt} {ctrl} "Left"}   {action "CaretWordLeftExtend"}}
...
|| Клипборд
{shortcat {key {ctrl}  "C"}             {action "Copy"}}
{shortcat {key {ctrl}  "Insert"}        {action "Copy"}}
{shortcat {key {ctrl}  "V"}             {action "Paste"}}
{shortcat {key {shift} "Insert"}        {action "Paste"}}
{shortcat {key {ctrl}  "X"}             {action "Cut"}}
{shortcat {key {shift} "Delete"}        {action "Cut"}}

{shortcat
        {key {ctrl}  "C"}
        {key {ctrl}  "Insert"}
    {action "Copy"}}
{shortcat
        {key {ctrl}  "V"}
        {key {shift} "Insert"}
    {action "Paste"}}
{shortcat
        {key {ctrl}  "X"}
        {key {shift} "Delete"}
    {action "Cut"}}

E>void    OnLButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);
E>void    OnRButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags);
E>void    OnMouseMove(HWND hwnd, int x, int y, UINT keyFlags);
E>

[MethodShortcut(Shortcut.CtrlB, "Выделить жирным ()", "Поместить тег [b] вокруг выделенной области.")]
[StripEventHandler("select-bold")]
public void InsertBoldTag()
{
    TagClicked("b|b|0");
}

[MethodShortcut(Shortcut.CtrlI, "Выделить курсивом ([i])", "Выделить текст курсивом")]
[StripEventHandler("select-italic")]
public void InsertItalicTag()
{
    TagClicked("i|i|0");
}

[MethodShortcut(Shortcut.CtrlK, "Вставить URL", "Вставить URL")]
[StripEventHandler("insert-url")]
public void InsertUrlTag()
{
    TagClicked("url=|url|0");
}