text-encapsulated-converter.go

/*
	https://docs.microsoft.com/en-us/openspecs/exchange_server_protocols/ms-oxrtfex/906fbb0f-2467-490e-8c3e-bdc31c5e9d35
*/

package rtfconverter

import (
	"bytes"
	"encoding/binary"
	"errors"
	"strconv"
)

type rtfTextEncapsulatedInterpreter struct {
	content            bytes.Buffer
	insideHtmlTagGroup int
	rtfEncoding        string
	defaultFont        int
	fontTable          map[int]*rtfFontTableItem
	colorTable         []rtfColor
	styleTag           string

	// keep the initial state when a group is parsed
	groupsInitialStates []rtfState

	// keep the previous state of the parsed group
	groupPreviousState rtfState

	// keep the current state of the parsed group
	groupCurrentState rtfState

	// count how many style tag are opened
	styleTagOpened int

	bodyStarted bool
	bodyStopped bool
}

func (p *rtfTextEncapsulatedInterpreter) Parse(rtfObj RtfStructure) ([]byte, error) {

	p.content = bytes.Buffer{}
	p.insideHtmlTagGroup = 0

	if !rtfObj.IsValid() {
		return nil, errors.New("The RTF file is not valid.")
	}

	p.parseElement(rtfObj.Root)

	buf, _ := ConvertToUtf8(p.content.Bytes(), p.rtfEncoding)
	return buf, nil
}

/**
 * detect the rtf element from structure and decide the parser
 * @param  {[type]} p *rtfTextEncapsulatedInterpreter) parseElement(item rtfElement [description]
 * @return {[type]}   [description]
 */
func (p *rtfTextEncapsulatedInterpreter) parseElement(item rtfElement) {
	switch item.(type) {
	case *rtfGroup:
		p.parseGroup(item.(*rtfGroup))
	case *rtfControlSymbol:
		p.parseControlSymbol(item.(*rtfControlSymbol))
	case *rtfControlWord:
		p.parseControlWord(item.(*rtfControlWord))
	case *rtfText:
		p.parseText(item.(*rtfText))

	}
}

/**
 * parse a rtf group
 * @param  {[type]} p *rtfTextEncapsulatedInterpreter) parseGroup(item *rtfGroup [description]
 * @return {[type]}   [description]
 */
func (p *rtfTextEncapsulatedInterpreter) parseGroup(item *rtfGroup) {
	children := item.GetChildren()

	if item.IsFontTable() {
		p.parseFontTableGroup(item)
	} else if item.IsColorTable() {
		p.parseColorTableGroup(item)
	} else if item.IsStylesheet() || item.IsTrackChanges() || item.IsInfo() || item.IsListtables() || item.IsFilesTable() {
		// ignore all these groups
	} else {
		if !item.IsDestination() {
			for _, child := range children {
				p.parseElement(child)
			}
		}
	}

}

/**
 * 	extract font table
 *   {' \fonttbl (<fontinfo> | ('{' <fontinfo> '}'))+ '}'
 *   <fontnum><fontfamily><fcharset>?<fprq>?<panose>?
 *   <nontaggedname>?<fontemb>?<codepage>? <fontname><fontaltname>? ';'
 *
 * @param  {[type]} p *rtfTextEncapsulatedInterpreter) parseFontTableGroup(item *rtfGroup [description]
 * @return {[type]}   [description]
 */
func (p *rtfTextEncapsulatedInterpreter) parseFontTableGroup(item *rtfGroup) {
	p.fontTable = map[int]*rtfFontTableItem{}
	for _, child := range item.children {
		switch child.(type) {
		case *rtfGroup:
			if child.(*rtfGroup).IsFontInfo() {
				p.parseFontInfoGroup(child.(*rtfGroup))
			}
		}
	}
}
func (p *rtfTextEncapsulatedInterpreter) parseFontInfoGroup(item *rtfGroup) {
	var (
		fontIdx int
	)

	for _, child := range item.GetChildren() {
		switch cobj := child.(type) {
		case *rtfControlWord:
			switch cobj.GetWord() {
			case "f":
				fontIdx = cobj.GetIntParameter()
				p.fontTable[fontIdx] = &rtfFontTableItem{}
			case "fnil", "froman", "fswiss", "fmodern", "fscript", "fdecor", "ftech", "fbidi":
				// font fammily
				if ftItem, ok := p.fontTable[fontIdx]; ok {
					ftItem.familyCode = cobj.GetWord()
				}
			case "fcharset":
				if ftItem, ok := p.fontTable[fontIdx]; ok {
					ftItem.charsetIndex = cobj.GetIntParameter()
				}
			}
		case *rtfText:
			if ftItem, ok := p.fontTable[fontIdx]; ok {
				ftItem.familyName = string(bytes.TrimRight(cobj.GetContent(), ";"))
			}
		case *rtfGroup:
			if cobj.IsFontAlternative() {
				// check alternative font
				if len(cobj.children) >= 3 {
					switch cobj.children[2].(type) {
					case *rtfText:
						if ftItem, ok := p.fontTable[fontIdx]; ok {
							ftItem.familyAlternativeName = string(cobj.children[2].(*rtfText).GetContent())
						}
					}

				}
			}
		}
	}
}

/**
 * extract colors from colortbl tag
 *  {\colortbl;\red0\green0\blue0;}
 * Index 0 of the RTF color table  is the 'auto' color
 * @param  {[type]} p *rtfTextEncapsulatedInterpreter) parseColorTableGroup(item *rtfGroup [description]
 * @return {[type]}   [description]
 */
func (p *rtfTextEncapsulatedInterpreter) parseColorTableGroup(item *rtfGroup) {
	if !item.IsColorTable() {
		return
	}

	color := rtfColor{
		r: 0,
		g: 0,
		b: 0,
	}
	for _, child := range item.GetChildren() {
		switch child.(type) {
		case *rtfControlWord:
			switch child.(*rtfControlWord).GetWord() {
			case "red":
				color.r = child.(*rtfControlWord).GetIntParameter()
			case "green":
				color.g = child.(*rtfControlWord).GetIntParameter()
			case "blue":
				color.b = child.(*rtfControlWord).GetIntParameter()
			}

		case *rtfText:
			// an end of color if marked by a ; text
			p.colorTable = append(p.colorTable, color)

			// reset color
			color = rtfColor{
				r: 0,
				g: 0,
				b: 0,
			}
		}
	}
}

func (p *rtfTextEncapsulatedInterpreter) parseControlSymbol(item *rtfControlSymbol) {
	switch item.GetSymbol() {
	case "'":
		// convert the string, reprezenting an hex number to a decimal number
		v, err := strconv.ParseInt(item.GetParameter(), 16, 16)
		if err == nil {
			b := make([]byte, 2)
			binary.LittleEndian.PutUint16(b, uint16(v))
			b = bytes.TrimRight(b, "\x00")
			p.content.Write(b)
		}
	case "~":
		p.content.WriteString("-")
	case "_":
		p.content.WriteString("_")
	}
}

func (p *rtfTextEncapsulatedInterpreter) parseControlWord(item *rtfControlWord) {
	// no control words will be added if are inside an htmltag
	switch item.GetWord() {
	case "u":
		i, err := strconv.Atoi(item.GetParameter())
		if err == nil {
			buff := new(bytes.Buffer)
			binary.Write(buff, binary.LittleEndian, i)
			p.content.Write(buff.Bytes())
			//p.content.WriteRune(rune(i))
		}
		return
	case "lquote":
		p.content.WriteString("'")
		return
	case "rquote":
		p.content.WriteString("'")
		return
	case "ldblquote":
		p.content.WriteString("\"")
		return
	case "rdblquote":
		p.content.WriteString("\"")
		return
	case "bullet":
		//p.content.WriteString("&bull;")
		return
	case "endash":
		p.content.WriteString("-")
		return
	case "emdash":
		p.content.WriteString("--")
		return

	case "line": // new line
		p.content.WriteString("\r\n")
		return
	case "par":
		p.content.WriteString("\r\n")
		return
	case "tab": // tab
		p.content.WriteString("\t")
		return
	case "deff":
		p.defaultFont = item.GetIntParameter()
	case "ansi", "mac", "pc", "pca":
		p.rtfEncoding, _ = GetEncodingFromCodepage(item.GetWord())
		return
	case "ansicpg":
		if item.GetIntParameter() > 0 {
			p.rtfEncoding, _ = GetEncodingFromCodepage(item.GetParameter())
		}
		return
	case "f", "fs":
		// font
		return
	}
}

func (p *rtfTextEncapsulatedInterpreter) parseText(item *rtfText) {
	// ignore any text outside an htmlTag group
	p.content.Write(item.GetContent())
}