RichTextBoxEx

 using System;
 using System.Collections.Specialized;
 using System.Drawing;
 using System.Drawing.Imaging;
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Windows.Forms;
 namespace RichTextBoxEx.Controls
 {
     #region Public Enums
     //可能的RTF颜色枚举
     public enum RtfColor
     {
         Black, Maroon, Green, Olive, Navy, Purple, Teal, Gray, Silver,
         Red, Lime, Yellow, Blue, Fuchsia, Aqua, White
     }
     #endregion
     /// <summary>
     /// This class adds the following functionality to RichTextBox:
     ///
     /// 1. Allows plain text to be inserted or appended programmatically to RTF
     ///  content.
     /// 2. Allows the font, text color, and highlight color of plain text to be
     ///  specified when inserting or appending text as RTF.
     /// 3. Allows images to be inserted programmatically, or with interaction from
     ///  the user.
     /// </summary>
     /// <remarks>
     /// Many solutions to the problem of programmatically inserting images
     /// into a RichTextBox use the clipboard or hard code the RTF for
     /// the image in the program.  This class is an attempt to make the process of
     /// inserting images at runtime more flexible without the overhead of maintaining
     /// the clipboard or the use of huge, cumbersome strings.
     ///
     /// RTF Specification v1.6 was used and is referred to many times in this document.
     /// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnrtfspec/html/rtfspec.asp
     ///
     /// For information about the RichEdit (Unmanaged RichTextBox) ...
     /// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/shellcc/platform/commctls/richedit/richeditcontrols/aboutricheditcontrols.asp
     /// </remarks>
     public class ExRichTextBox : System.Windows.Forms.RichTextBox
     {
         #region My Enums
         // Specifies the flags/options for the unmanaged call to the GDI+ method
         // Metafile.EmfToWmfBits().
         private enum EmfToWmfBitsFlags
         {
             // Use the default conversion
             EmfToWmfBitsFlagsDefault = 0x00000000,
             // Embedded the source of the EMF metafiel within the resulting WMF
             // metafile
             EmfToWmfBitsFlagsEmbedEmf = 0x00000001,
             // Place a 22-byte header in the resulting WMF file.  The header is
             // required for the metafile to be considered placeable.
             EmfToWmfBitsFlagsIncludePlaceable = 0x00000002,
             // Don't simulate clipping by using the XOR operator.
             EmfToWmfBitsFlagsNoXORClip = 0x00000004
         };
         #endregion
         #region My Structs
         // Definitions for colors in an RTF document
         private struct RtfColorDef
         {
             public const string Black = @"\red0\green0\blue0";
             public const string Maroon = @"\red128\green0\blue0";
             public const string Green = @"\red0\green128\blue0";
             public const string Olive = @"\red128\green128\blue0";
             public const string Navy = @"\red0\green0\blue128";
             public const string Purple = @"\red128\green0\blue128";
             public const string Teal = @"\red0\green128\blue128";
             public const string Gray = @"\red128\green128\blue128";
             public const string Silver = @"\red192\green192\blue192";
             public const string Red = @"\red255\green0\blue0";
             public const string Lime = @"\red0\green255\blue0";
             public const string Yellow = @"\red255\green255\blue0";
             public const string Blue = @"\red0\green0\blue255";
             public const string Fuchsia = @"\red255\green0\blue255";
             public const string Aqua = @"\red0\green255\blue255";
             public const string White = @"\red255\green255\blue255";
         }
         // Control words for RTF font families
         private struct RtfFontFamilyDef
         {
             public const string Unknown = @"\fnil";
             public const string Roman = @"\froman";
             public const string Swiss = @"\fswiss";
             public const string Modern = @"\fmodern";
             public const string Script = @"\fscript";
             public const string Decor = @"\fdecor";
             public const string Technical = @"\ftech";
             public const string BiDirect = @"\fbidi";
         }
         #endregion
         #region My Constants
         // Not used in this application.  Descriptions can be found with documentation
         // of Windows GDI function SetMapMode
         private const int MM_TEXT = ;
         private const int MM_LOMETRIC = ;
         private const int MM_HIMETRIC = ;
         private const int MM_LOENGLISH = ;
         private const int MM_HIENGLISH = ;
         private const int MM_TWIPS = ;
         // Ensures that the metafile maintains a 1:1 aspect ratio
         private const int MM_ISOTROPIC = ;
         // Allows the x-coordinates and y-coordinates of the metafile to be adjusted
         // independently
         private const int MM_ANISOTROPIC = ;
         // Represents an unknown font family
         private const string FF_UNKNOWN = "UNKNOWN";
         // The number of hundredths of millimeters (0.01 mm) in an inch
         // For more information, see GetImagePrefix() method.
         private const int HMM_PER_INCH = ;
         // The number of twips in an inch
         // For more information, see GetImagePrefix() method.
         private const int TWIPS_PER_INCH = ;
         #endregion
         #region My Privates
         // The default text color
         private RtfColor textColor;
         // The default text background color
         private RtfColor highlightColor;
         // Dictionary that maps color enums to RTF color codes
         private HybridDictionary rtfColor;
         // Dictionary that mapas Framework font families to RTF font families
         private HybridDictionary rtfFontFamily;
         // The horizontal resolution at which the control is being displayed
         private float xDpi;
         // The vertical resolution at which the control is being displayed
         private float yDpi;
         #endregion
         #region Elements required to create an RTF document
         /* RTF HEADER
    * ----------
    *
    * \rtf[N]  - For text to be considered to be RTF, it must be enclosed in this tag.
    *      rtf1 is used because the RichTextBox conforms to RTF Specification
    *      version 1.
    * \ansi  - The character set.
    * \ansicpg[N] - Specifies that unicode characters might be embedded. ansicpg1252
    *      is the default used by Windows.
    * \deff[N]  - The default font. \deff0 means the default font is the first font
    *      found.
    * \deflang[N] - The default language. \deflang1033 specifies US English.
    * */
         private const string RTF_HEADER = @"{\rtf1\ansi\ansicpg1252\deff0\deflang1033";
         /* RTF DOCUMENT AREA
          * -----------------
          *
          * \viewkind[N] - The type of view or zoom level.  \viewkind4 specifies normal view.
          * \uc[N]  - The number of bytes corresponding to a Unicode character.
          * \pard  - Resets to default paragraph properties
          * \cf[N]  - Foreground color.  \cf1 refers to the color at index 1 in
          *      the color table
          * \f[N]  - Font number. \f0 refers to the font at index 0 in the font
          *      table.
          * \fs[N]  - Font size in half-points.
          * */
         private const string RTF_DOCUMENT_PRE = @"\viewkind4\uc1\pard\cf1\f0\fs20";
         private const string RTF_DOCUMENT_POST = @"\cf0\fs17}";
         private string RTF_IMAGE_POST = @"}";
         #endregion
         #region Accessors
         // TODO: This can be ommitted along with RemoveBadCharacters
         // Overrides the default implementation of RTF.  This is done because the control
         // was originally developed to run in an instant messenger that uses the
         // Jabber XML-based protocol.  The framework would throw an exception when the
         // XML contained the null character, so I filtered out.
         public new string Rtf
         {
             get { return RemoveBadChars(base.Rtf); }
             set { base.Rtf = value; }
         }
         // The color of the text
         public RtfColor TextColor
         {
             get { return textColor; }
             set { textColor = value; }
         }
         // The color of the highlight
         public RtfColor HiglightColor
         {
             get { return highlightColor; }
             set { highlightColor = value; }
         }
         #endregion
         #region Constructors
         /// <summary>
         /// Initializes the text colors, creates dictionaries for RTF colors and
         /// font families, and stores the horizontal and vertical resolution of
         /// the RichTextBox's graphics context.
         /// </summary>
         public ExRichTextBox()
             : base()
         {
             // Initialize default text and background colors
             textColor = RtfColor.Black;
             highlightColor = RtfColor.White;
             // Initialize the dictionary mapping color codes to definitions
             rtfColor = new HybridDictionary();
             rtfColor.Add(RtfColor.Aqua, RtfColorDef.Aqua);
             rtfColor.Add(RtfColor.Black, RtfColorDef.Black);
             rtfColor.Add(RtfColor.Blue, RtfColorDef.Blue);
             rtfColor.Add(RtfColor.Fuchsia, RtfColorDef.Fuchsia);
             rtfColor.Add(RtfColor.Gray, RtfColorDef.Gray);
             rtfColor.Add(RtfColor.Green, RtfColorDef.Green);
             rtfColor.Add(RtfColor.Lime, RtfColorDef.Lime);
             rtfColor.Add(RtfColor.Maroon, RtfColorDef.Maroon);
             rtfColor.Add(RtfColor.Navy, RtfColorDef.Navy);
             rtfColor.Add(RtfColor.Olive, RtfColorDef.Olive);
             rtfColor.Add(RtfColor.Purple, RtfColorDef.Purple);
             rtfColor.Add(RtfColor.Red, RtfColorDef.Red);
             rtfColor.Add(RtfColor.Silver, RtfColorDef.Silver);
             rtfColor.Add(RtfColor.Teal, RtfColorDef.Teal);
             rtfColor.Add(RtfColor.White, RtfColorDef.White);
             rtfColor.Add(RtfColor.Yellow, RtfColorDef.Yellow);
             // Initialize the dictionary mapping default Framework font families to
             // RTF font families
             rtfFontFamily = new HybridDictionary();
             rtfFontFamily.Add(FontFamily.GenericMonospace.Name, RtfFontFamilyDef.Modern);
             rtfFontFamily.Add(FontFamily.GenericSansSerif, RtfFontFamilyDef.Swiss);
             rtfFontFamily.Add(FontFamily.GenericSerif, RtfFontFamilyDef.Roman);
             rtfFontFamily.Add(FF_UNKNOWN, RtfFontFamilyDef.Unknown);
             // Get the horizontal and vertical resolutions at which the object is
             // being displayed
             using (Graphics _graphics = this.CreateGraphics())
             {
                 xDpi = _graphics.DpiX;
                 yDpi = _graphics.DpiY;
             }
         }
         /// <summary>
         /// Calls the default constructor then sets the text color.
         /// </summary>
         /// <param name="_textColor"></param>
         public ExRichTextBox(RtfColor _textColor)
             : this()
         {
             textColor = _textColor;
         }
         /// <summary>
         /// Calls the default constructor then sets te text and highlight colors.
         /// </summary>
         /// <param name="_textColor"></param>
         /// <param name="_highlightColor"></param>
         public ExRichTextBox(RtfColor _textColor, RtfColor _highlightColor)
             : this()
         {
             textColor = _textColor;
             highlightColor = _highlightColor;
         }
         #endregion
         #region Append RTF or Text to RichTextBox Contents
         /// <summary>
         /// Assumes the string passed as a paramter is valid RTF text and attempts
         /// to append it as RTF to the content of the control.
         /// </summary>
         /// <param name="_rtf"></param>
         public void AppendRtf(string _rtf)
         {
             // Move caret to the end of the text
             this.Select(this.TextLength, );
             // Since SelectedRtf is null, this will append the string to the
             // end of the existing RTF
             this.SelectedRtf = _rtf;
         }
         /// <summary>
         /// Assumes that the string passed as a parameter is valid RTF text and
         /// attempts to insert it as RTF into the content of the control.
         /// </summary>
         /// <remarks>
         /// NOTE: The text is inserted wherever the caret is at the time of the call,
         /// and if any text is selected, that text is replaced.
         /// </remarks>
         /// <param name="_rtf"></param>
         public void InsertRtf(string _rtf)
         {
             this.SelectedRtf = _rtf;
         }
         /// <summary>
         /// Appends the text using the current font, text, and highlight colors.
         /// </summary>
         /// <param name="_text"></param>
         public void AppendTextAsRtf(string _text)
         {
             AppendTextAsRtf(_text, this.Font);
         }

         /// <summary>
         /// Appends the text using the given font, and current text and highlight
         /// colors.
         /// </summary>
         /// <param name="_text"></param>
         /// <param name="_font"></param>
         public void AppendTextAsRtf(string _text, Font _font)
         {
             AppendTextAsRtf(_text, _font, textColor);
         }
         /// <summary>
         /// Appends the text using the given font and text color, and the current
         /// highlight color.
         /// </summary>
         /// <param name="_text"></param>
         /// <param name="_font"></param>
         /// <param name="_color"></param>
         public void AppendTextAsRtf(string _text, Font _font, RtfColor _textColor)
         {
             AppendTextAsRtf(_text, _font, _textColor, highlightColor);
         }
         /// <summary>
         /// Appends the text using the given font, text, and highlight colors.  Simply
         /// moves the caret to the end of the RichTextBox's text and makes a call to
         /// insert.
         /// </summary>
         /// <param name="_text"></param>
         /// <param name="_font"></param>
         /// <param name="_textColor"></param>
         /// <param name="_backColor"></param>
         public void AppendTextAsRtf(string _text, Font _font, RtfColor _textColor, RtfColor _backColor)
         {
             // Move carret to the end of the text
             this.Select(this.TextLength, );
             InsertTextAsRtf(_text, _font, _textColor, _backColor);
         }
         #endregion
         #region Insert Plain Text
         /// <summary>
         /// Inserts the text using the current font, text, and highlight colors.
         /// </summary>
         /// <param name="_text"></param>
         public void InsertTextAsRtf(string _text)
         {
             InsertTextAsRtf(_text, this.Font);
         }

         /// <summary>
         /// Inserts the text using the given font, and current text and highlight
         /// colors.
         /// </summary>
         /// <param name="_text"></param>
         /// <param name="_font"></param>
         public void InsertTextAsRtf(string _text, Font _font)
         {
             InsertTextAsRtf(_text, _font, textColor);
         }
         /// <summary>
         /// Inserts the text using the given font and text color, and the current
         /// highlight color.
         /// </summary>
         /// <param name="_text"></param>
         /// <param name="_font"></param>
         /// <param name="_color"></param>
         public void InsertTextAsRtf(string _text, Font _font, RtfColor _textColor)
         {
             InsertTextAsRtf(_text, _font, _textColor, highlightColor);
         }
         /// <summary>
         /// Inserts the text using the given font, text, and highlight colors.  The
         /// text is wrapped in RTF codes so that the specified formatting is kept.
         /// You can only assign valid RTF to the RichTextBox.Rtf property, else
         /// an exception is thrown.  The RTF string should follow this format ...
         ///
         /// {\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{[FONTS]}{\colortbl ;[COLORS]}}
         /// \viewkind4\uc1\pard\cf1\f0\fs20 [DOCUMENT AREA] }
         ///
         /// </summary>
         /// <remarks>
         /// NOTE: The text is inserted wherever the caret is at the time of the call,
         /// and if any text is selected, that text is replaced.
         /// </remarks>
         /// <param name="_text"></param>
         /// <param name="_font"></param>
         /// <param name="_color"></param>
         /// <param name="_color"></param>
         public void InsertTextAsRtf(string _text, Font _font, RtfColor _textColor, RtfColor _backColor)
         {
             StringBuilder _rtf = new StringBuilder();
             // Append the RTF header
             _rtf.Append(RTF_HEADER);
             // Create the font table from the font passed in and append it to the
             // RTF string
             _rtf.Append(GetFontTable(_font));
             // Create the color table from the colors passed in and append it to the
             // RTF string
             _rtf.Append(GetColorTable(_textColor, _backColor));
             // Create the document area from the text to be added as RTF and append
             // it to the RTF string.
             _rtf.Append(GetDocumentArea(_text, _font));
             this.SelectedRtf = _rtf.ToString();
         }
         /// <summary>
         /// Creates the Document Area of the RTF being inserted. The document area
         /// (in this case) consists of the text being added as RTF and all the
         /// formatting specified in the Font object passed in. This should have the
         /// form ...
         ///
         /// \viewkind4\uc1\pard\cf1\f0\fs20 [DOCUMENT AREA] }
         ///
         /// </summary>
         /// <param name="_text"></param>
         /// <param name="_font"></param>
         /// <returns>
         /// The document area as a string.
         /// </returns>
         private string GetDocumentArea(string _text, Font _font)
         {
             StringBuilder _doc = new StringBuilder();
             // Append the standard RTF document area control string
             _doc.Append(RTF_DOCUMENT_PRE);
             // Set the highlight color (the color behind the text) to the
             // third color in the color table.  See GetColorTable for more details.
             _doc.Append(@"\highlight2");
             // If the font is bold, attach corresponding tag
             if (_font.Bold)
                 _doc.Append(@"\b");
             // If the font is italic, attach corresponding tag
             if (_font.Italic)
                 _doc.Append(@"\i");
             // If the font is strikeout, attach corresponding tag
             if (_font.Strikeout)
                 _doc.Append(@"\strike");
             // If the font is underlined, attach corresponding tag
             if (_font.Underline)
                 _doc.Append(@"\ul");
             // Set the font to the first font in the font table.
             // See GetFontTable for more details.
             _doc.Append(@"\f0");
             // Set the size of the font.  In RTF, font size is measured in
             // half-points, so the font size is twice the value obtained from
             // Font.SizeInPoints
             _doc.Append(@"\fs");
             _doc.Append((int)Math.Round(( * _font.SizeInPoints)));
             // Apppend a space before starting actual text (for clarity)
             _doc.Append(@" ");
             // Append actual text, however, replace newlines with RTF \par.
             // Any other special text should be handled here (e.g.) tabs, etc.
             _doc.Append(_text.Replace("\n", @"\par "));
             // RTF isn't strict when it comes to closing control words, but what the
             // heck ...
             // Remove the highlight
             _doc.Append(@"\highlight0");
             // If font is bold, close tag
             if (_font.Bold)
                 _doc.Append(@"\b0");
             // If font is italic, close tag
             if (_font.Italic)
                 _doc.Append(@"\i0");
             // If font is strikeout, close tag
             if (_font.Strikeout)
                 _doc.Append(@"\strike0");
             // If font is underlined, cloes tag
             if (_font.Underline)
                 _doc.Append(@"\ulnone");
             // Revert back to default font and size
             _doc.Append(@"\f0");
             _doc.Append(@"\fs20");
             // Close the document area control string
             _doc.Append(RTF_DOCUMENT_POST);
             return _doc.ToString();
         }
         #endregion
         #region Insert Image
         /// <summary>
         /// Inserts an image into the RichTextBox.  The image is wrapped in a Windows
         /// Format Metafile, because although Microsoft discourages the use of a WMF,
         /// the RichTextBox (and even MS Word), wraps an image in a WMF before inserting
         /// the image into a document.  The WMF is attached in HEX format (a string of
         /// HEX numbers).
         ///
         /// The RTF Specification v1.6 says that you should be able to insert bitmaps,
         /// .jpegs, .gifs, .pngs, and Enhanced Metafiles (.emf) directly into an RTF
         /// document without the WMF wrapper. This works fine with MS Word,
         /// however, when you don't wrap images in a WMF, WordPad and
         /// RichTextBoxes simply ignore them.  Both use the riched20.dll or msfted.dll.
         /// </summary>
         /// <remarks>
         /// NOTE: The image is inserted wherever the caret is at the time of the call,
         /// and if any text is selected, that text is replaced.
         /// </remarks>
         /// <param name="_image"></param>
         public void InsertImage(Image _image)
         {
             StringBuilder _rtf = new StringBuilder();
             // Append the RTF header
             _rtf.Append(RTF_HEADER);
             // Create the font table using the RichTextBox's current font and append
             // it to the RTF string
             _rtf.Append(GetFontTable(this.Font));
             // Create the image control string and append it to the RTF string
             _rtf.Append(GetImagePrefix(_image));
             // Create the Windows Metafile and append its bytes in HEX format
             _rtf.Append(GetRtfImage(_image));
             // Close the RTF image control string
             _rtf.Append(RTF_IMAGE_POST);
             this.SelectedRtf = _rtf.ToString();
         }
         /// <summary>
         /// Creates the RTF control string that describes the image being inserted.
         /// This description (in this case) specifies that the image is an
         /// MM_ANISOTROPIC metafile, meaning that both X and Y axes can be scaled
         /// independently.  The control string also gives the images current dimensions,
         /// and its target dimensions, so if you want to control the size of the
         /// image being inserted, this would be the place to do it. The prefix should
         /// have the form ...
         ///
         /// {\pict\wmetafile8\picw[A]\pich[B]\picwgoal[C]\pichgoal[D]
         ///
         /// where ...
         ///
         /// A = current width of the metafile in hundredths of millimeters (0.01mm)
         ///  = Image Width in Inches * Number of (0.01mm) per inch
         ///  = (Image Width in Pixels / Graphics Context's Horizontal Resolution) * 2540
         ///  = (Image Width in Pixels / Graphics.DpiX) * 2540
         ///
         /// B = current height of the metafile in hundredths of millimeters (0.01mm)
         ///  = Image Height in Inches * Number of (0.01mm) per inch
         ///  = (Image Height in Pixels / Graphics Context's Vertical Resolution) * 2540
         ///  = (Image Height in Pixels / Graphics.DpiX) * 2540
         ///
         /// C = target width of the metafile in twips
         ///  = Image Width in Inches * Number of twips per inch
         ///  = (Image Width in Pixels / Graphics Context's Horizontal Resolution) * 1440
         ///  = (Image Width in Pixels / Graphics.DpiX) * 1440
         ///
         /// D = target height of the metafile in twips
         ///  = Image Height in Inches * Number of twips per inch
         ///  = (Image Height in Pixels / Graphics Context's Horizontal Resolution) * 1440
         ///  = (Image Height in Pixels / Graphics.DpiX) * 1440
         /// 
         /// </summary>
         /// <remarks>
         /// The Graphics Context's resolution is simply the current resolution at which
         /// windows is being displayed.  Normally it's 96 dpi, but instead of assuming
         /// I just added the code.
         ///
         /// According to Ken Howe at pbdr.com, "Twips are screen-independent units
         /// used to ensure that the placement and proportion of screen elements in
         /// your screen application are the same on all display systems."
         ///
         /// Units Used
         /// ----------
         /// 1 Twip = 1/20 Point
         /// 1 Point = 1/72 Inch
         /// 1 Twip = 1/1440 Inch
         ///
         /// 1 Inch = 2.54 cm
         /// 1 Inch = 25.4 mm
         /// 1 Inch = 2540 (0.01)mm
         /// </remarks>
         /// <param name="_image"></param>
         /// <returns></returns>
         private string GetImagePrefix(Image _image)
         {
             StringBuilder _rtf = new StringBuilder();
             // Calculate the current width of the image in (0.01)mm
             int picw = (int)Math.Round((_image.Width / xDpi) * HMM_PER_INCH);
             // Calculate the current height of the image in (0.01)mm
             int pich = (int)Math.Round((_image.Height / yDpi) * HMM_PER_INCH);
             // Calculate the target width of the image in twips
             int picwgoal = (int)Math.Round((_image.Width / xDpi) * TWIPS_PER_INCH);
             // Calculate the target height of the image in twips
             int pichgoal = (int)Math.Round((_image.Height / yDpi) * TWIPS_PER_INCH);
             // Append values to RTF string
             _rtf.Append(@"{\pict\wmetafile8");
             _rtf.Append(@"\picw");
             _rtf.Append(picw);
             _rtf.Append(@"\pich");
             _rtf.Append(pich);
             _rtf.Append(@"\picwgoal");
             _rtf.Append(picwgoal);
             _rtf.Append(@"\pichgoal");
             _rtf.Append(pichgoal);
             _rtf.Append(" ");
             return _rtf.ToString();
         }
         /// <summary>
         /// Use the EmfToWmfBits function in the GDI+ specification to convert a
         /// Enhanced Metafile to a Windows Metafile
         /// </summary>
         /// <param name="_hEmf">
         /// A handle to the Enhanced Metafile to be converted
         /// </param>
         /// <param name="_bufferSize">
         /// The size of the buffer used to store the Windows Metafile bits returned
         /// </param>
         /// <param name="_buffer">
         /// An array of bytes used to hold the Windows Metafile bits returned
         /// </param>
         /// <param name="_mappingMode">
         /// The mapping mode of the image.  This control uses MM_ANISOTROPIC.
         /// </param>
         /// <param name="_flags">
         /// Flags used to specify the format of the Windows Metafile returned
         /// </param>
         [DllImportAttribute("gdiplus.dll")]
         private static extern uint GdipEmfToWmfBits(IntPtr _hEmf, uint _bufferSize,
             byte[] _buffer, int _mappingMode, EmfToWmfBitsFlags _flags);

         /// <summary>
         /// Wraps the image in an Enhanced Metafile by drawing the image onto the
         /// graphics context, then converts the Enhanced Metafile to a Windows
         /// Metafile, and finally appends the bits of the Windows Metafile in HEX
         /// to a string and returns the string.
         /// </summary>
         /// <param name="_image"></param>
         /// <returns>
         /// A string containing the bits of a Windows Metafile in HEX
         /// </returns>
         private string GetRtfImage(Image _image)
         {
             StringBuilder _rtf = null;
             // Used to store the enhanced metafile
             MemoryStream _stream = null;
             // Used to create the metafile and draw the image
             Graphics _graphics = null;
             // The enhanced metafile
             Metafile _metaFile = null;
             // Handle to the device context used to create the metafile
             IntPtr _hdc;
             try
             {
                 _rtf = new StringBuilder();
                 _stream = new MemoryStream();
                 // Get a graphics context from the RichTextBox
                 using (_graphics = this.CreateGraphics())
                 {
                     // Get the device context from the graphics context
                     _hdc = _graphics.GetHdc();
                     // Create a new Enhanced Metafile from the device context
                     _metaFile = new Metafile(_stream, _hdc);
                     // Release the device context
                     _graphics.ReleaseHdc(_hdc);
                 }
                 // Get a graphics context from the Enhanced Metafile
                 using (_graphics = Graphics.FromImage(_metaFile))
                 {
                     // Draw the image on the Enhanced Metafile
                     _graphics.DrawImage(_image, new Rectangle(, , _image.Width, _image.Height));
                 }
                 // Get the handle of the Enhanced Metafile
                 IntPtr _hEmf = _metaFile.GetHenhmetafile();
                 // A call to EmfToWmfBits with a null buffer return the size of the
                 // buffer need to store the WMF bits.  Use this to get the buffer
                 // size.
                 uint _bufferSize = GdipEmfToWmfBits(_hEmf, , null, MM_ANISOTROPIC,
                     EmfToWmfBitsFlags.EmfToWmfBitsFlagsDefault);
                 // Create an array to hold the bits
                 byte[] _buffer = new byte[_bufferSize];
                 // A call to EmfToWmfBits with a valid buffer copies the bits into the
                 // buffer an returns the number of bits in the WMF. 
                 uint _convertedSize = GdipEmfToWmfBits(_hEmf, _bufferSize, _buffer, MM_ANISOTROPIC,
                     EmfToWmfBitsFlags.EmfToWmfBitsFlagsDefault);
                 // Append the bits to the RTF string
                 for (int i = ; i < _buffer.Length; ++i)
                 {
                     _rtf.Append(String.Format("{0:X2}", _buffer[i]));
                 }
                 return _rtf.ToString();
             }
             finally
             {
                 if (_graphics != null)
                     _graphics.Dispose();
                 if (_metaFile != null)
                     _metaFile.Dispose();
                 if (_stream != null)
                     _stream.Close();
             }
         }
         #endregion
         #region RTF Helpers
         /// <summary>
         /// Creates a font table from a font object.  When an Insert or Append
         /// operation is performed a font is either specified or the default font
         /// is used.  In any case, on any Insert or Append, only one font is used,
         /// thus the font table will always contain a single font.  The font table
         /// should have the form ...
         ///
         /// {\fonttbl{\f0\[FAMILY]\fcharset0 [FONT_NAME];}
         /// </summary>
         /// <param name="_font"></param>
         /// <returns></returns>
         private string GetFontTable(Font _font)
         {
             StringBuilder _fontTable = new StringBuilder();
             // Append table control string
             _fontTable.Append(@"{\fonttbl{\f0");
             _fontTable.Append(@"\");
             // If the font's family corresponds to an RTF family, append the
             // RTF family name, else, append the RTF for unknown font family.
             if (rtfFontFamily.Contains(_font.FontFamily.Name))
                 _fontTable.Append(rtfFontFamily[_font.FontFamily.Name]);
             else
                 _fontTable.Append(rtfFontFamily[FF_UNKNOWN]);
             // \fcharset specifies the character set of a font in the font table.
             // 0 is for ANSI.
             _fontTable.Append(@"\fcharset0 ");
             // Append the name of the font
             _fontTable.Append(_font.Name);
             // Close control string
             _fontTable.Append(@";}}");
             return _fontTable.ToString();
         }
         /// <summary>
         /// Creates a font table from the RtfColor structure.  When an Insert or Append
         /// operation is performed, _textColor and _backColor are either specified
         /// or the default is used.  In any case, on any Insert or Append, only three
         /// colors are used.  The default color of the RichTextBox (signified by a
         /// semicolon (;) without a definition), is always the first color (index 0) in
         /// the color table.  The second color is always the text color, and the third
         /// is always the highlight color (color behind the text).  The color table
         /// should have the form ...
         ///
         /// {\colortbl ;[TEXT_COLOR];[HIGHLIGHT_COLOR];}
         ///
         /// </summary>
         /// <param name="_textColor"></param>
         /// <param name="_backColor"></param>
         /// <returns></returns>
         private string GetColorTable(RtfColor _textColor, RtfColor _backColor)
         {
             StringBuilder _colorTable = new StringBuilder();
             // Append color table control string and default font (;)
             _colorTable.Append(@"{\colortbl ;");
             // Append the text color
             _colorTable.Append(rtfColor[_textColor]);
             _colorTable.Append(@";");
             // Append the highlight color
             _colorTable.Append(rtfColor[_backColor]);
             _colorTable.Append(@";}\n");
             return _colorTable.ToString();
         }
         /// <summary>
         /// Called by overrided RichTextBox.Rtf accessor.
         /// Removes the null character from the RTF.  This is residue from developing
         /// the control for a specific instant messaging protocol and can be ommitted.
         /// </summary>
         /// <param name="_originalRtf"></param>
         /// <returns>RTF without null character</returns>
         private string RemoveBadChars(string _originalRtf)
         {
             return _originalRtf.Replace("\0", "");
         }
         #endregion
     }
 }