// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// Copyright (c) 2005 Novell, Inc. (http://www.novell.com)
//
// Authors:
// Peter Bartok (pbartok@novell.com)
//
// COMPLETE
#undef RTF_DEBUG
using System;
using System.Collections;
using System.IO;
using System.Text;
namespace System.Windows.Forms.RTF{
internal class RTF {
#region Local Variables
internal const char EOF = unchecked((char)-1);
internal const int NoParam = -1000000;
internal const int DefaultEncodingCodePage = 1252;
private TokenClass rtf_class;
private Major major;
private Minor minor;
private int param;
private string encoded_text;
private Encoding encoding;
private int encoding_code_page = DefaultEncodingCodePage;
private StringBuilder text_buffer;
private Picture picture;
private int line_num;
private int line_pos;
private char pushed_char;
//private StringBuilder pushed_text_buffer;
private TokenClass pushed_class;
private Major pushed_major;
private Minor pushed_minor;
private int pushed_param;
private char prev_char;
private bool bump_line;
private Font font_list;
private Charset cur_charset;
private Stack charset_stack;
private Style styles;
private Color colors;
private Font fonts;
private StreamReader source;
private static Hashtable key_table;
private static KeyStruct[] Keys = KeysInit.Init();
private DestinationCallback destination_callbacks;
private ClassCallback class_callbacks;
#endregion // Local Variables
#region Constructors
static RTF() {
key_table = new Hashtable(Keys.Length);
for (int i = 0; i < Keys.Length; i++) {
key_table[Keys[i].Symbol] = Keys[i];
}
}
public RTF(Stream stream) {
source = new StreamReader(stream);
text_buffer = new StringBuilder(1024);
//pushed_text_buffer = new StringBuilder(1024);
rtf_class = TokenClass.None;
pushed_class = TokenClass.None;
pushed_char = unchecked((char)-1);
line_num = 0;
line_pos = 0;
prev_char = unchecked((char)-1);
bump_line = false;
font_list = null;
charset_stack = null;
cur_charset = new Charset();
destination_callbacks = new DestinationCallback();
class_callbacks = new ClassCallback();
destination_callbacks [Minor.OptDest] = new DestinationDelegate (HandleOptDest);
destination_callbacks[Minor.FontTbl] = new DestinationDelegate(ReadFontTbl);
destination_callbacks[Minor.ColorTbl] = new DestinationDelegate(ReadColorTbl);
destination_callbacks[Minor.StyleSheet] = new DestinationDelegate(ReadStyleSheet);
destination_callbacks[Minor.Info] = new DestinationDelegate(ReadInfoGroup);
destination_callbacks[Minor.Pict] = new DestinationDelegate(ReadPictGroup);
destination_callbacks[Minor.Object] = new DestinationDelegate(ReadObjGroup);
}
#endregion // Constructors
#region Properties
public TokenClass TokenClass {
get {
return this.rtf_class;
}
set {
this.rtf_class = value;
}
}
public Major Major {
get {
return this.major;
}
set {
this.major = value;
}
}
public Minor Minor {
get {
return this.minor;
}
set {
this.minor = value;
}
}
public int Param {
get {
return this.param;
}
set {
this.param = value;
}
}
public string Text {
get {
return this.text_buffer.ToString();
}
set {
if (value == null) {
this.text_buffer.Length = 0;
} else {
this.text_buffer = new StringBuilder(value);
}
}
}
public string EncodedText {
get { return encoded_text; }
}
public Picture Picture {
get { return picture; }
set { picture = value; }
}
public Color Colors {
get {
return colors;
}
set {
colors = value;
}
}
public Style Styles {
get {
return styles;
}
set {
styles = value;
}
}
public Font Fonts {
get {
return fonts;
}
set {
fonts = value;
}
}
public ClassCallback ClassCallback {
get {
return class_callbacks;
}
set {
class_callbacks = value;
}
}
public DestinationCallback DestinationCallback {
get {
return destination_callbacks;
}
set {
destination_callbacks = value;
}
}
public int LineNumber {
get {
return line_num;
}
}
public int LinePos {
get {
return line_pos;
}
}
#endregion // Properties
#region Methods
/// <summary>Set the default font for documents without font table</summary>
public void DefaultFont(string name) {
Font font;
font = new Font(this);
font.Num = 0;
font.Name = name;
}
/// <summary>Read the next character from the input - skip any crlf</summary>
private char GetChar ()
{
return GetChar (true);
}
/// <summary>Read the next character from the input</summary>
private char GetChar(bool skipCrLf)
{
int c;
bool old_bump_line;
SkipCRLF:
if ((c = source.Read()) != -1) {
this.text_buffer.Append((char) c);
}
if (this.prev_char == EOF) {
this.bump_line = true;
}
old_bump_line = bump_line;
bump_line = false;
if (skipCrLf) {
if (c == '\r') {
bump_line = true;
text_buffer.Length--;
goto SkipCRLF;
} else if (c == '\n') {
bump_line = true;
if (this.prev_char == '\r') {
old_bump_line = false;
}
text_buffer.Length--;
goto SkipCRLF;
}
}
this.line_pos ++;
if (old_bump_line) {
this.line_num++;
this.line_pos = 1;
}
this.prev_char = (char) c;
return (char) c;
}
/// <summary>Parse the RTF stream</summary>
public void Read() {
while (GetToken() != TokenClass.EOF) {
RouteToken();
}
}
/// <summary>Route a token</summary>
public void RouteToken() {
if (CheckCM(TokenClass.Control, Major.Destination)) {
DestinationDelegate d;
d = destination_callbacks[minor];
if (d != null) {
d(this);
}
}
// Invoke class callback if there is one
ClassDelegate c;
c = class_callbacks[rtf_class];
if (c != null) {
c(this);
}
}
/// <summary>Skip to the end of the next group to start or current group we are in</summary>
public void SkipGroup() {
int level;
level = 1;
while (GetToken() != TokenClass.EOF) {
if (rtf_class == TokenClass.Group) {
if (this.major == Major.BeginGroup) {
level++;
} else if (this.major == Major.EndGroup) {
level--;
if (level < 1) {
break;
}
}
}
}
}
/// <summary>Return the next token in the stream</summary>
public TokenClass GetToken() {
if (pushed_class != TokenClass.None) {
this.rtf_class = this.pushed_class;
this.major = this.pushed_major;
this.minor = this.pushed_minor;
this.param = this.pushed_param;
this.pushed_class = TokenClass.None;
return this.rtf_class;
}
GetToken2();
if (this.rtf_class == TokenClass.Text) {
this.minor = (Minor)this.cur_charset[(int)this.major];
if (encoding == null) {
encoding = Encoding.GetEncoding (encoding_code_page);
}
encoded_text = new String (encoding.GetChars (new byte [] { (byte) this.major }));
}
if (this.cur_charset.Flags == CharsetFlags.None) {
return this.rtf_class;
}
if (CheckCMM (TokenClass.Control, Major.Unicode, Minor.UnicodeAnsiCodepage)) {
encoding_code_page = param;
// fallback to the default one in case we have an invalid value
if (encoding_code_page < 0 || encoding_code_page > 65535)
encoding_code_page = DefaultEncodingCodePage;
}
if (((this.cur_charset.Flags & CharsetFlags.Read) != 0) && CheckCM(TokenClass.Control, Major.CharSet)) {
this.cur_charset.ReadMap();
} else if (((this.cur_charset.Flags & CharsetFlags.Switch) != 0) && CheckCMM(TokenClass.Control, Major.CharAttr, Minor.FontNum)) {
Font fp;
fp = Font.GetFont(this.font_list, this.param);
if (fp != null) {
if (fp.Name.StartsWith("Symbol")) {
this.cur_charset.ID = CharsetType.Symbol;
} else {
this.cur_charset.ID = CharsetType.General;
}
} else if (((this.cur_charset.Flags & CharsetFlags.Switch) != 0) && (this.rtf_class == TokenClass.Group)) {
switch(this.major) {
case Major.BeginGroup: {
this.charset_stack.Push(this.cur_charset);
break;
}
case Major.EndGroup: {
this.cur_charset = (Charset)this.charset_stack.Pop();
break;
}
}
}
}
return this.rtf_class;
}
private void GetToken2() {
char c;
int sign;
this.rtf_class = TokenClass.Unknown;
this.param = NoParam;
this.text_buffer.Length = 0;
if (this.pushed_char != EOF) {
c = this.pushed_char;
this.text_buffer.Append(c);
this.pushed_char = EOF;
} else if ((c = GetChar()) == EOF) {
this.rtf_class = TokenClass.EOF;
return;
}
if (c == '{') {
this.rtf_class = TokenClass.Group;
this.major = Major.BeginGroup;
return;
}
if (c == '}') {
this.rtf_class = TokenClass.Group;
this.major = Major.EndGroup;
return;
}
if (c != '\\') {
if (c != '\t') {
this.rtf_class = TokenClass.Text;
this.major = (Major)c; // FIXME - typing?
return;
} else {
this.rtf_class = TokenClass.Control;
this.major = Major.SpecialChar;
this.minor = Minor.Tab;
return;
}
}
if ((c = GetChar()) == EOF) {
// Not so good
return;
}
if (!Char.IsLetter(c)) {
if (c == '\'') {
char c2;
if ((c = GetChar()) == EOF) {
return;
}
if ((c2 = GetChar()) == EOF) {
return;
}
this.rtf_class = TokenClass.Text;
this.major = (Major)((Char)((Convert.ToByte(c.ToString(), 16) * 16 + Convert.ToByte(c2.ToString(), 16))));
return;
}
// Escaped char
if (c == ':' || c == '{' || c == '}' || c == '\\') {
this.rtf_class = TokenClass.Text;
this.major = (Major)c;
return;
}
Lookup(this.text_buffer.ToString());
return;
}
while (Char.IsLetter(c)) {
if ((c = GetChar(false)) == EOF) {
break;
}
}
if (c != EOF) {
this.text_buffer.Length--;
}
Lookup(this.text_buffer.ToString());
if (c != EOF) {
this.text_buffer.Append(c);
}
sign = 1;
if (c == '-') {
sign = -1;
c = GetChar();
}
if (c != EOF && Char.IsDigit(c) && minor != Minor.PngBlip) {
this.param = 0;
while (Char.IsDigit(c)) {
this.param = this.param * 10 + Convert.ToByte(c) - 48;
if ((c = GetChar()) == EOF) {
break;
}
}
this.param *= sign;
}
if (c != EOF) {
if (c != ' ' && c != '\r' && c != '\n') {
this.pushed_char = c;
}
this.text_buffer.Length--;
}
}
public void SetToken(TokenClass cl, Major maj, Minor min, int par, string text) {
this.rtf_class = cl;
this.major = maj;
this.minor = min;
this.param = par;
if (par == NoParam) {
this.text_buffer = new StringBuilder(text);
} else {
this.text_buffer = new StringBuilder(text + par.ToString());
}
}
public void UngetToken() {
if (this.pushed_class != TokenClass.None) {
throw new RTFException(this, "Cannot unget more than one token");
}
if (this.rtf_class == TokenClass.None) {
throw new RTFException(this, "No token to unget");
}
this.pushed_class = this.rtf_class;
this.pushed_major = this.major;
this.pushed_minor = this.minor;
this.pushed_param = this.param;
//this.pushed_text_buffer = new StringBuilder(this.text_buffer.ToString());
}
public TokenClass PeekToken() {
GetToken();
UngetToken();
return rtf_class;
}
public void Lookup(string token) {
Object obj;
KeyStruct key;
obj = key_table[token.Substring(1)];
if (obj == null) {
rtf_class = TokenClass.Unknown;
major = (Major) -1;
minor = (Minor) -1;
return;
}
key = (KeyStruct)obj;
this.rtf_class = TokenClass.Control;
this.major = key.Major;
this.minor = key.Minor;
}
public bool CheckCM(TokenClass rtf_class, Major major) {
if ((this.rtf_class == rtf_class) && (this.major == major)) {
return true;
}
return false;
}
public bool CheckCMM(TokenClass rtf_class, Major major, Minor minor) {
if ((this.rtf_class == rtf_class) && (this.major == major) && (this.minor == minor)) {
return true;
}
return false;
}
public bool CheckMM(Major major, Minor minor) {
if ((this.major == major) && (this.minor == minor)) {
return true;
}
return false;
}
#endregion // Methods
#region Default Delegates
private void HandleOptDest (RTF rtf)
{
int group_levels = 1;
while (true) {
GetToken ();
// Here is where we should handle recognised optional
// destinations.
//
// Handle a picture group
//
if (rtf.CheckCMM (TokenClass.Control, Major.Destination, Minor.Pict)) {
ReadPictGroup (rtf);
return;
}
if (rtf.CheckCM (TokenClass.Group, Major.EndGroup)) {
if ((--group_levels) == 0) {
break;
}
}
if (rtf.CheckCM (TokenClass.Group, Major.BeginGroup)) {
group_levels++;
}
}
}
private void ReadFontTbl(RTF rtf) {
int old;
Font font;
old = -1;
font = null;
while (true) {
rtf.GetToken();
if (rtf.CheckCM(TokenClass.Group, Major.EndGroup)) {
break;
}
if (old < 0) {
if (rtf.CheckCMM(TokenClass.Control, Major.CharAttr, Minor.FontNum)) {
old = 1;
} else if (rtf.CheckCM(TokenClass.Group, Major.BeginGroup)) {
old = 0;
} else {
throw new RTFException(rtf, "Cannot determine format");
}
}
if (old == 0) {
if (!rtf.CheckCM(TokenClass.Group, Major.BeginGroup)) {
throw new RTFException(rtf, "missing \"{\"");
}
rtf.GetToken();
}
font = new Font(rtf);
while ((rtf.rtf_class != TokenClass.EOF) && (!rtf.CheckCM(TokenClass.Text, (Major)';')) && (!rtf.CheckCM(TokenClass.Group, Major.EndGroup))) {
if (rtf.rtf_class == TokenClass.Control) {
switch(rtf.major) {
case Major.FontFamily: {
font.Family = (int)rtf.minor;
break;
}
case Major.CharAttr: {
switch(rtf.minor) {
case Minor.FontNum: {
font.Num = rtf.param;
break;
}
default: {
#if RTF_DEBUG
Console.WriteLine("Got unhandled Control.CharAttr.Minor: " + rtf.minor);
#endif
break;
}
}
break;
}
case Major.FontAttr: {
switch (rtf.minor) {
case Minor.FontCharSet: {
font.Charset = (CharsetType)rtf.param;
break;
}
case Minor.FontPitch: {
font.Pitch = rtf.param;
break;
}
case Minor.FontCodePage: {
font.Codepage = rtf.param;
break;
}
case Minor.FTypeNil:
case Minor.FTypeTrueType: {
font.Type = rtf.param;
break;
}
default: {
#if RTF_DEBUG
Console.WriteLine("Got unhandled Control.FontAttr.Minor: " + rtf.minor);
#endif
break;
}
}
break;
}
default: {
#if RTF_DEBUG
Console.WriteLine("ReadFontTbl: Unknown Control token " + rtf.major);
#endif
break;
}
}
} else if (rtf.CheckCM(TokenClass.Group, Major.BeginGroup)) {
rtf.SkipGroup();
} else if (rtf.rtf_class == TokenClass.Text) {
StringBuilder sb;
sb = new StringBuilder();
while ((rtf.rtf_class != TokenClass.EOF) && (!rtf.CheckCM(TokenClass.Text, (Major)';')) && (!rtf.CheckCM(TokenClass.Group, Major.EndGroup)) && (!rtf.CheckCM(TokenClass.Group, Major.BeginGroup))) {
sb.Append((char)rtf.major);
rtf.GetToken();
}
if (rtf.CheckCM(TokenClass.Group, Major.EndGroup)) {
rtf.UngetToken();
}
font.Name = sb.ToString();
continue;
#if RTF_DEBUG
} else {
Console.WriteLine("ReadFontTbl: Unknown token " + rtf.text_buffer);
#endif
}
rtf.GetToken();
}
if (old == 0) {
rtf.GetToken();
if (!rtf.CheckCM(TokenClass.Group, Major.EndGroup)) {
throw new RTFException(rtf, "Missing \"}\"");
}
}
}
if (font == null) {
throw new RTFException(rtf, "No font created");
}
if (font.Num == -1) {
throw new RTFException(rtf, "Missing font number");
}
rtf.RouteToken();
}
private void ReadColorTbl(RTF rtf) {
Color color;
int num;
num = 0;
while (true) {
rtf.GetToken();
if (rtf.CheckCM(TokenClass.Group, Major.EndGroup)) {
break;
}
color = new Color(rtf);
color.Num = num++;
while (rtf.CheckCM(TokenClass.Control, Major.ColorName)) {
switch (rtf.minor) {
case Minor.Red: {
color.Red = rtf.param;
break;
}
case Minor.Green: {
color.Green = rtf.param;
break;
}
case Minor.Blue: {
color.Blue = rtf.param;
break;
}
}
rtf.GetToken();
}
if (!rtf.CheckCM(TokenClass.Text, (Major)';')) {
throw new RTFException(rtf, "Malformed color entry");
}
}
rtf.RouteToken();
}
private void ReadStyleSheet(RTF rtf) {
Style style;
StringBuilder sb;
sb = new StringBuilder();
while (true) {
rtf.GetToken();
if (rtf.CheckCM(TokenClass.Group, Major.EndGroup)) {
break;
}
style = new Style(rtf);
if (!rtf.CheckCM(TokenClass.Group, Major.BeginGroup)) {
throw new RTFException(rtf, "Missing \"{\"");
}
while (true) {
rtf.GetToken();
if ((rtf.rtf_class == TokenClass.EOF) || rtf.CheckCM(TokenClass.Text, (Major)';')) {
break;
}
if (rtf.rtf_class == TokenClass.Control) {
if (rtf.CheckMM(Major.ParAttr, Minor.StyleNum)) {
style.Num = rtf.param;
style.Type = StyleType.Paragraph;
continue;
}
if (rtf.CheckMM(Major.CharAttr, Minor.CharStyleNum)) {
style.Num = rtf.param;
style.Type = StyleType.Character;
continue;
}
if (rtf.CheckMM(Major.StyleAttr, Minor.SectStyleNum)) {
style.Num = rtf.param;
style.Type = StyleType.Section;
continue;
}
if (rtf.CheckMM(Major.StyleAttr, Minor.BasedOn)) {
style.BasedOn = rtf.param;
continue;
}
if (rtf.CheckMM(Major.StyleAttr, Minor.Additive)) {
style.Additive = true;
continue;
}
if (rtf.CheckMM(Major.StyleAttr, Minor.Next)) {
style.NextPar = rtf.param;
continue;
}
new StyleElement(style, rtf.rtf_class, rtf.major, rtf.minor, rtf.param, rtf.text_buffer.ToString());
} else if (rtf.CheckCM(TokenClass.Group, Major.BeginGroup)) {
// This passes over "{\*\keycode ... }, among other things
rtf.SkipGroup();
} else if (rtf.rtf_class == TokenClass.Text) {
while (rtf.rtf_class == TokenClass.Text) {
if (rtf.major == (Major)';') {
rtf.UngetToken();
break;
}
sb.Append((char)rtf.major);
rtf.GetToken();
}
style.Name = sb.ToString();
#if RTF_DEBUG
} else {
Console.WriteLine("ReadStyleSheet: Ignored token " + rtf.text_buffer);
#endif
}
}
rtf.GetToken();
if (!rtf.CheckCM(TokenClass.Group, Major.EndGroup)) {
throw new RTFException(rtf, "Missing EndGroup (\"}\"");
}
// Sanity checks
if (style.Name == null) {
throw new RTFException(rtf, "Style must have name");
}
if (style.Num < 0) {
if (!sb.ToString().StartsWith("Normal") && !sb.ToString().StartsWith("Standard")) {
throw new RTFException(rtf, "Missing style number");
}
style.Num = Style.NormalStyleNum;
}
if (style.NextPar == -1) {
style.NextPar = style.Num;
}
}
rtf.RouteToken();
}
private void ReadInfoGroup(RTF rtf) {
rtf.SkipGroup();
rtf.RouteToken();
}
private void ReadPictGroup(RTF rtf)
{
bool read_image_data = false;
Picture picture = new Picture ();
while (true) {
rtf.GetToken ();
if (rtf.CheckCM (TokenClass.Group, Major.EndGroup))
break;
switch (minor) {
case Minor.PngBlip:
picture.ImageType = minor;
read_image_data = true;
break;
case Minor.WinMetafile:
picture.ImageType = minor;
read_image_data = true;
continue;
case Minor.PicWid:
continue;
case Minor.PicHt:
continue;
case Minor.PicGoalWid:
picture.SetWidthFromTwips (param);
continue;
case Minor.PicGoalHt:
picture.SetHeightFromTwips (param);
continue;
}
if (read_image_data && rtf.rtf_class == TokenClass.Text) {
picture.Data.Seek (0, SeekOrigin.Begin);
//char c = (char) rtf.major;
uint digitValue1;
uint digitValue2;
char hexDigit1 = (char) rtf.major;
char hexDigit2;
while (true) {
while (hexDigit1 == '\n' || hexDigit1 == '\r') {
hexDigit1 = (char) source.Peek ();
if (hexDigit1 == '}')
break;
hexDigit1 = (char) source.Read ();
}
hexDigit2 = (char) source.Peek ();
if (hexDigit2 == '}')
break;
hexDigit2 = (char) source.Read ();
while (hexDigit2 == '\n' || hexDigit2 == '\r') {
hexDigit2 = (char) source.Peek ();
if (hexDigit2 == '}')
break;
hexDigit2 = (char) source.Read ();
}
if (Char.IsDigit (hexDigit1))
digitValue1 = (uint) (hexDigit1 - '0');
else if (Char.IsLower (hexDigit1))
digitValue1 = (uint) (hexDigit1 - 'a' + 10);
else if (Char.IsUpper (hexDigit1))
digitValue1 = (uint) (hexDigit1 - 'A' + 10);
else if (hexDigit1 == '\n' || hexDigit1 == '\r')
continue;
else
break;
if (Char.IsDigit (hexDigit2))
digitValue2 = (uint) (hexDigit2 - '0');
else if (Char.IsLower (hexDigit2))
digitValue2 = (uint) (hexDigit2 - 'a' + 10);
else if (Char.IsUpper (hexDigit2))
digitValue2 = (uint) (hexDigit2 - 'A' + 10);
else if (hexDigit2 == '\n' || hexDigit2 == '\r')
continue;
else
break;
picture.Data.WriteByte ((byte) checked (digitValue1 * 16 + digitValue2));
// We get the first hex digit at the end, since in the very first
// iteration we use rtf.major as the first hex digit
hexDigit1 = (char) source.Peek ();
if (hexDigit1 == '}')
break;
hexDigit1 = (char) source.Read ();
}
read_image_data = false;
break;
}
}
if (picture.ImageType != Minor.Undefined && !read_image_data) {
this.picture = picture;
SetToken (TokenClass.Control, Major.PictAttr, picture.ImageType, 0, String.Empty);
}
}
private void ReadObjGroup(RTF rtf) {
rtf.SkipGroup();
rtf.RouteToken();
}
#endregion // Default Delegates
}
}
|