/// <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((2 * _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> /// <res> /// 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. /// </res> /// <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> /// <res> /// 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 /// </res> /// <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(0, 0, _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, 0, 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 = 0; 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 } }
PictureBox pb = new PictureBox();
pb.Image = (new Icon("App.ico")).ToBitmap();
this.richTextBox1.Controls.Add(pb);
///////////////////////////////////public void InsertImage()
{
bool b = rtb1.ReadOnly;
Image img = Image.FromFile("sss.bmp");
Clipboard.SetDataObject(img);
rtb1.ReadOnly = false;
rtb1.Paste(DataFormats.GetFormat(DataFormats.Bitmap));
rtb1.ReadOnly = b;
}
楼主可以结贴了
PictureBox pb = new PictureBox();
pb.Image = (new Icon("App.ico")).ToBitmap();
this.richTextBox1.Controls.Add(pb);
///////////////////////////////////public void InsertImage()
{
bool b = rtb1.ReadOnly;
Image img = Image.FromFile("sss.bmp");
Clipboard.SetDataObject(img);
rtb1.ReadOnly = false;
rtb1.Paste(DataFormats.GetFormat(DataFormats.Bitmap));
rtb1.ReadOnly = b;
}一定可以的
/// 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((2 * _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
/// 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>
/// <res>
/// 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.
/// </res>
/// <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>
/// <res>
/// 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
/// </res>
/// <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();
}
/// 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(0, 0, _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, 0, 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 = 0; 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
}
}