/// <summary> /// Internally parses tag and returns it from point when left angular bracket was found /// </summary> /// <returns>Chunk</returns> internal HTMLchunk GetNextTag() { oChunk = oTP.ParseTag(ref iCurPos); // for backwards compatibility mark closed tags with params as open if (oChunk.iParams > 0 && bAutoMarkClosedTagsWithParamsAsOpen && oChunk.oType == HTMLchunkType.CloseTag) { oChunk.oType = HTMLchunkType.OpenTag; } // 012345 // check for start of script if (oChunk.sTag.Length == 6 && oChunk.sTag[0] == 's' && oChunk.sTag == "script") { if (!oChunk.bClosure) { oChunk.oType = HTMLchunkType.Script; oChunk = oTP.ParseScript(ref iCurPos); return(oChunk); } } oChunk.iChunkLength = iCurPos - oChunk.iChunkOffset; if (bKeepRawHTML) { oChunk.oHTML = oEnc.GetString(bHTML, oChunk.iChunkOffset, oChunk.iChunkLength); } return(oChunk); }
private void Dispose(bool bDisposing) { if (!bDisposed) { bDisposed = true; if (oChunk != null) { oChunk.Dispose(); oChunk = null; } if (sText != null) { sText.Dispose(); sText = null; } bHTML = null; if (oE != null) { oE.Dispose(); oE = null; } if (oTP != null) { oTP.Dispose(); oTP = null; } } }
private void Dispose(bool bDisposing) { if (!bDisposed) { bDisposed = true; bHTML = null; oChunk = null; sText = null; oE = null; oP = null; } }
/// <summary> /// Inits tag parser /// </summary> /// <param name="p_oChunk"></param> /// <param name="p_sText"></param> internal void Init(HtmlParser p_oP, HTMLchunk p_oChunk, DynaString p_sText, byte[] p_bHTML, int p_iDataLength, HTMLentities p_oE, HTMLheuristics p_oHE) { oP = p_oP; oChunk = p_oChunk; sText = p_sText; bHTML = p_bHTML; iDataLength = p_iDataLength; // we don't want to be too close to end of data when dealing with heuristics iMaxHeuDataLength = iDataLength - MIN_DATA_SIZE_FOR_HEURISTICS; oE = p_oE; oHE = p_oHE; }
/// <summary> /// Internal: parses tag that started from current position /// </summary> /// <returns>HTMLchunk with tag information</returns> internal HTMLchunk ParseTag(ref int iCurPos) { byte cChar = 0; byte cPeek = 0; // initialise peeked char - this will point to the next after < character if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos]; // in case of comments ! must follow immediately after < if (cPeek == (byte)'!') { if (iCurPos + 2 < iDataLength && bHTML[iCurPos + 1] == (byte)'-' && bHTML[iCurPos + 2] == (byte)'-') { // we detected start of comments here, instead of parsing the rest here we will // call special function tuned to do the job much more effectively oChunk.sTag = "!--"; oChunk.oType = HTMLchunkType.Comment; oChunk.bComments = true; iCurPos += 3; bool bFullTag; oChunk = ParseComments(ref iCurPos, out bFullTag); oChunk.iChunkLength = iCurPos - oChunk.iChunkOffset; if (oP.bAutoKeepComments || oP.bKeepRawHTML) { if (!oP.bAutoExtractBetweenTagsOnly) { oChunk.oHTML = GetString(oChunk.iChunkOffset, oChunk.iChunkLength); } else { oChunk.oHTML = GetString(oChunk.iChunkOffset + 4, oChunk.iChunkLength - (bFullTag ? 7 : 4)); } } return(oChunk); } } } else { // empty tag but its not closed, so we will call it open... oChunk.oType = HTMLchunkType.OpenTag; // end of data... before it started return(oChunk); } // tag ID, non-zero if matched by heuristics engine int iTagID = 0; // STAGE 0: lets try some heuristics to see if we can quickly identify most common tags // that should be present most of the time, this should save a lot of looping and string creation if (bEnableHeuristics && iCurPos < iMaxHeuDataLength) { // check if we have got closure of the tag if (cPeek == (byte)'/') { oChunk.bClosure = true; oChunk.bEndClosure = false; oChunk.oType = HTMLchunkType.CloseTag; iCurPos++; cPeek = bHTML[iCurPos]; } cChar = bHTML[iCurPos + 1]; // probability of having a match is very high (or so we expect) iTagID = oHE.MatchTag(cPeek, cChar); if (iTagID != 0) { if (iTagID < 0) { iTagID *= -1; // single character tag oChunk.sTag = oHE.GetString(iTagID); // see if we got fully closed tag if (cChar == (byte)'>') { iCurPos += 2; goto ReturnChunk; } cPeek = cChar; iCurPos++; // everything else means we need to continue scanning as we may have params and stuff goto AttributeParsing; } else { // ok, we have here 2 or more character string that we need to check further // often when we have full 2 char match the next char will be >, if that's the case // then we definately matched our tag byte cNextChar = bHTML[iCurPos + 2]; if (cNextChar == (byte)'>') { //oChunk.sTag=oHE.GetString(iTagID); oChunk.sTag = oHE.GetTwoCharString(cPeek, cChar); iCurPos += 3; goto ReturnChunk; } // ok, check next char for space, if that's the case we still got our tag // but need to skip to attribute parsing if (cNextChar == (byte)' ') { //oChunk.sTag=oHE.GetString(iTagID); oChunk.sTag = oHE.GetTwoCharString(cPeek, cChar); iCurPos += 2; cPeek = cNextChar; goto AttributeParsing; } // ok, we are not very lucky, but it is still worth fighting for // now we need to check fully long string against what we have matched, maybe // we got exact match and we can avoid full parsing of the tag byte[] bTag = oHE.GetStringData(iTagID); if (iCurPos + bTag.Length + 5 >= iDataLength) { goto TagParsing; } // in a loop (and this is not an ideal solution, but still) for (int i = 2; i < bTag.Length; i++) { // if a single char is not matched, then we if (bTag[i] != bHTML[iCurPos + i]) { goto TagParsing; } } // ok we matched full long word, but we need to be sure that char // after the word is ' ' or '>' as otherwise we may have matched prefix of even longer // word cNextChar = bHTML[iCurPos + bTag.Length]; if (cNextChar == (byte)'>') { oChunk.sTag = oHE.GetString(iTagID); iCurPos += bTag.Length + 1; goto ReturnChunk; } if (cNextChar == (byte)' ') { cPeek = cNextChar; oChunk.sTag = oHE.GetString(iTagID); iCurPos += bTag.Length; goto AttributeParsing; } // no luck: we need to parse tag fully as our heuristical matching failed miserably :'o( } } } TagParsing: sText.Clear(); byte bCharType = 0; // STAGE 1: parse tag (anything until > or /> or whitespace leading to start of attribute) while (cPeek != 0) { bCharType = bTagCharTypes[cPeek]; //if(cPeek<=32 && bWhiteSpace[cPeek]==1) if (bCharType == (byte)TagCharType.WhiteSpace) { iCurPos++; // speculative loop unroll -- we have a very good chance of seeing non-space char next // so instead of setting up loop we will just read it directly, this should save ticks // on having to prepare while() loop if (iCurPos < iDataLength) { cChar = bHTML[iCurPos++]; } else { cChar = 0; } bCharType = bTagCharTypes[cChar]; //if(cChar==' ' || cChar=='\t' || cChar==13 || cChar==10) //if(cChar<=32 && bWhiteSpace[cChar]==1) if (bCharType == (byte)TagCharType.WhiteSpace) { while (iCurPos < iDataLength) { cChar = bHTML[iCurPos++]; bCharType = bTagCharTypes[cChar]; if (bCharType == (byte)TagCharType.WhiteSpace) //if(cChar!=' ' && cChar!='\t' && cChar!=13 && cChar!=10) { //cPeek=bHTML[iCurPos]; continue; } break; } if (iCurPos >= iDataLength) { cChar = 0; } } //bWhiteSpaceHere=true; // now, if we have already got tag it means that we are most likely // going to need to parse tag attributes if (sText.iBufPos > 0) { oChunk.sTag = sText.SetToStringASCII(); // oChunk.Append((byte)' '); iCurPos--; if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos]; } else { cPeek = 0; } break; } } else { // reuse Peeked char from previous run //cChar=cPeek; iCurPos++; if (iCurPos < iDataLength) { cChar = bHTML[iCurPos++]; } else { cChar = 0; } } if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos]; } else { cPeek = 0; } // most likely we should have lower-cased ASCII char if (bCharType == (byte)TagCharType.LowerCasedASCIIorDigit) { sText.bBuffer[sText.iBufPos++] = cChar; // oChunk.Append(cChar); continue; } // tag end - we did not have any params if (cChar == (byte)'>') { if (sText.iBufPos > 0) { oChunk.sTag = sText.SetToStringASCII(); } if (!oChunk.bClosure) { oChunk.oType = HTMLchunkType.OpenTag; } return(oChunk); } // closure of tag sign if (cChar == (byte)'/') { oChunk.bClosure = true; oChunk.bEndClosure = (sText.iBufPos > 0); oChunk.oType = HTMLchunkType.CloseTag; continue; } // nope, we have got upper cased ASCII char - this seems to be LESS likely than > and / //if(cChar>=65 && cChar<=90) if (bCharType > 32) { // bCharType in this case contains already lower-cased char sText.bBuffer[sText.iBufPos++] = bCharType; // oChunk.Append(bCharType); continue; } // ok, we have got some other char - we break out to deal with it in attributes part break; } if (cPeek == 0) { return(oChunk); } // if true then equal sign was found //bool bEqualsSign=false; // STAGE 2: parse attributes (if any available) // attribute name can be standalone or with value after = // attribute itself can't have entities or anything like this - we expect it to be in ASCII characters AttributeParsing: string sAttrName; if (iTagID != 0) { // first, skip whitespace: if (cPeek <= 32 && bTagCharTypes[cPeek] == (byte)TagCharType.WhiteSpace) { // most likely next char is not-whitespace iCurPos++; if (iCurPos >= iDataLength) { goto ReturnChunk; } cPeek = bHTML[iCurPos]; if (cPeek <= 32 && bTagCharTypes[cPeek] == (byte)TagCharType.WhiteSpace) { // ok long loop here then while (iCurPos < iDataLength) { cPeek = bHTML[iCurPos++]; if (cPeek <= 32 && bTagCharTypes[cPeek] == (byte)TagCharType.WhiteSpace) { continue; } break; } if (cPeek == (byte)'>') { goto ReturnChunk; } iCurPos--; if (iCurPos >= iDataLength) { goto ReturnChunk; } } if (iCurPos >= iDataLength) { goto ReturnChunk; } } // ok we have got matched tag, it is possible that we might be able to quickly match // attribute name known to be used for that tag: int iAttrID = oHE.MatchAttr(cPeek, iTagID); if (iAttrID > 0) { byte[] bAttr = oHE.GetAttrData(iAttrID); if (iCurPos + bAttr.Length + 2 >= iDataLength) { goto ActualAttributeParsing; } // in a loop (and this is not an ideal solution, but still) for (int i = 1; i < bAttr.Length; i++) { // if a single char is not matched, then we if (bAttr[i] != bHTML[iCurPos + i]) { goto ActualAttributeParsing; } } byte cNextChar = bHTML[iCurPos + bAttr.Length]; // ok, we expect next symbol to be = if (cNextChar == (byte)'=') { sAttrName = oHE.GetAttr(iAttrID); iCurPos += bAttr.Length + 1; cPeek = bHTML[iCurPos]; goto AttributeValueParsing; } } } ActualAttributeParsing: sText.Clear(); // doing exactly the same thing as in tag parsing while (cPeek != 0) { bCharType = bTagCharTypes[cPeek]; //if(cPeek<=32 && bWhiteSpace[cPeek]==1) if (bCharType == (byte)TagCharType.WhiteSpace) { iCurPos++; // speculative loop unroll -- we have a very good chance of seeing non-space char next // so instead of setting up loop we will just read it directly, this should save ticks // on having to prepare while() loop if (iCurPos < iDataLength) { cChar = bHTML[iCurPos++]; } else { cPeek = 0; break; } bCharType = bTagCharTypes[cChar]; //if(cChar==' ' || cChar=='\t' || cChar==13 || cChar==10) //if(cChar<=32 && bWhiteSpace[cChar]==1) if (bCharType == (byte)TagCharType.WhiteSpace) { while (iCurPos < iDataLength) { cChar = bHTML[iCurPos++]; bCharType = bTagCharTypes[cChar]; if (bCharType == (byte)TagCharType.WhiteSpace) //if(cChar!=' ' && cChar!='\t' && cChar!=13 && cChar!=10) { //cPeek=bHTML[iCurPos]; continue; } //if(cChar==(byte)'>') // goto ReturnChunk; //iCurPos--; break; } if (iCurPos >= iDataLength) { cChar = 0; cPeek = 0; break; } } //bWhiteSpaceHere=true; // now, if we have already got attribute name it means that we need to go to parse value (which may not be present) if (sText.iBufPos > 0) { // oChunk.Append((byte)' '); iCurPos--; if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos]; } else { cPeek = 0; } // ok, we have got attribute name and now we have got next char there // most likely we have got = here and then value if (cPeek == (byte)'=') { //bEqualsSign=true; // move forward one char iCurPos++; if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos]; } else { cPeek = 0; } break; } // or we can have end of tag itself, doh! if (cPeek == (byte)'>') { // move forward one char iCurPos++; if (sText.iBufPos > 0) { oChunk.AddParam(sText.SetToStringASCII(), "", (byte)' '); } if (!oChunk.bClosure) { oChunk.oType = HTMLchunkType.OpenTag; } return(oChunk); } // closure if (cPeek == (byte)'/') { oChunk.bClosure = true; oChunk.bEndClosure = true; oChunk.oType = HTMLchunkType.CloseTag; continue; } // ok, we have got new char starting after current attribute name is fully parsed // this means the attribute name is on its own and the char we found is start // of a new attribute oChunk.AddParam(sText.SetToStringASCII(), "", (byte)' '); sText.Clear(); goto AttributeParsing; } } else { // reuse Peeked char from previous run //cChar=cPeek; iCurPos++; if (iCurPos < iDataLength) { cChar = bHTML[iCurPos++]; } else { cChar = 0; } } if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos]; } else { cPeek = 0; } // most likely we should have lower-cased ASCII char here if (bCharType == (byte)TagCharType.LowerCasedASCIIorDigit) { sText.bBuffer[sText.iBufPos++] = cChar; // oChunk.Append(cChar); continue; } // = with attribute value to follow if (cChar == (byte)'=') { //bEqualsSign=true; break; } // nope, we have got upper cased ASCII char - this seems to be LESS likely than > and / //if(cChar>=65 && cChar<=90) if (bCharType > 32) { // bCharType in this case contains already lower-cased char sText.bBuffer[sText.iBufPos++] = bCharType; // oChunk.Append(bCharType); continue; } // tag end - we did not have any params if (cChar == (byte)'>') { if (sText.iBufPos > 0) { oChunk.AddParam(sText.SetToStringASCII(), "", (byte)' '); } if (!oChunk.bClosure) { oChunk.oType = HTMLchunkType.OpenTag; } return(oChunk); } // closure of tag sign if (cChar == (byte)'/') { oChunk.bClosure = true; oChunk.bEndClosure = true; oChunk.oType = HTMLchunkType.CloseTag; continue; } // some other char sText.bBuffer[sText.iBufPos++] = cChar; // oChunk.Append(cChar); } if (cPeek == 0) { if (sText.iBufPos > 0) { oChunk.AddParam(sText.SetToStringASCII(), "", (byte)' '); } if (!oChunk.bClosure) { oChunk.oType = HTMLchunkType.OpenTag; } return(oChunk); } sAttrName = sText.SetToStringASCII(); AttributeValueParsing: /// *********************************************************************** /// STAGE 3: parse attribute value /// *********************************************************************** // the value could be just string, or in quotes (single or double) // or we can have next attribute name start, in which case we will jump back to attribute parsing // for tracking quotes purposes byte cQuotes = cPeek; int iValueStartOffset; // skip whitespace if any if (cPeek <= 32 && bTagCharTypes[cPeek] == (byte)TagCharType.WhiteSpace) { iCurPos++; // speculative loop unroll -- we have a very good chance of seeing non-space char next // so instead of setting up loop we will just read it directly, this should save ticks // on having to prepare while() loop if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos]; } else { iValueStartOffset = iCurPos - 1; goto AttributeValueEnd; } //if(cChar==' ' || cChar=='\t' || cChar==13 || cChar==10) //if(cChar<=32 && bWhiteSpace[cChar]==1) if (cPeek <= 32 && bTagCharTypes[cPeek] == (byte)TagCharType.WhiteSpace) { while (iCurPos < iDataLength) { cPeek = bHTML[iCurPos++]; if (cPeek <= 32 && bTagCharTypes[cPeek] == (byte)TagCharType.WhiteSpace) //if(cChar!=' ' && cChar!='\t' && cChar!=13 && cChar!=10) { //cPeek=bHTML[iCurPos]; continue; } iCurPos--; break; } if (iCurPos >= iDataLength) { iValueStartOffset = iCurPos - 1; goto AttributeValueEnd; } } cQuotes = cPeek; } // because we deal with VALUE of the attribute it means we can't lower-case it, // or skip whitespace (if in quotes), which in practice means that we don't need to copy // it to temporary string buffer, we can just remember starting offset and then create string from // data in bHTML // ok, first char can be one of the quote chars or something else if (cPeek != '\"' && cPeek != '\'') { iValueStartOffset = iCurPos; cQuotes = (byte)' '; // any other char here means we have value up until next whitespace or end of tag // this gives us good opportunity to scan fairly quickly without otherwise redundant // checks - this should happen fairly rarely, however loop dealing with data between quotes // will happen often enough and its best to eliminate as much stuff from it as possible //sText.bBuffer[sText.iBufPos++]=cPeek; // move to next char if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos++]; } else { goto AttributeValueEnd; } while (cPeek != 0) { // if whitespace then we got our value and need to go back to param if (cPeek <= 32 && bTagCharTypes[cPeek] == (byte)TagCharType.WhiteSpace) { oChunk.AddParam(sAttrName, GetString(iValueStartOffset, iCurPos - iValueStartOffset - 1), (byte)' '); iCurPos--; goto AttributeParsing; } // end of tag? if (cPeek == (byte)'>') { //iCurPos--; break; } if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos++]; } else { iCurPos = iDataLength + 1; goto AttributeValueEnd; } } // ok we are done, add outstanding attribute oChunk.AddParam(sAttrName, GetString(iValueStartOffset, iCurPos - iValueStartOffset - 1), (byte)' '); goto ReturnChunk; } // move one step forward iCurPos++; iValueStartOffset = iCurPos; if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos++]; } else { goto AttributeValueEnd; } // attribute value parsing from between two quotes while (cPeek != 0) { // check whether we have got possible entity (can be anything starting with &) if (cPeek == 38) { int iPrevPos = iCurPos; char cEntityChar = oE.CheckForEntity(bHTML, ref iCurPos, iDataLength); // restore current symbol if (cEntityChar == 0) { if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos++]; } else { break; } //sText.bBuffer[sText.iBufPos++]=38; //(byte)'&';; continue; } else { // okay we have got an entity, our hope of not having to copy stuff into variable // is over, we have to continue in a slower fashion :( // but thankfully this should happen very rarely, so, annoying to code, but // most codepaths will run very fast! int iPreEntLen = iPrevPos - iValueStartOffset - 1; // 14/05/08 need to clear text - it contains attribute name text sText.Clear(); // copy previous data if (iPreEntLen > 0) { Array.Copy(bHTML, iValueStartOffset, sText.bBuffer, 0, iPreEntLen); sText.iBufPos = iPreEntLen; } // we have to skip now to next byte, since // some converted chars might well be control chars like > oChunk.bEntities = true; if (cChar == (byte)'<') { oChunk.bLtEntity = true; } // unless is space we will ignore it // note that this won't work if is defined as it should // byte int value of 160, rather than 32. //if(cChar!=' ') sText.Append(cEntityChar); if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos++]; } else { goto AttributeValueEnd; } // okay, we continue here using in effect new inside loop as we might have more entities here // attribute value parsing from between two quotes while (cPeek != 0) { // check whether we have got possible entity (can be anything starting with &) if (cPeek == 38) { char cNewEntityChar = oE.CheckForEntity(bHTML, ref iCurPos, iDataLength); // restore current symbol if (cNewEntityChar != 0) { if (cNewEntityChar == (byte)'<') { oChunk.bLtEntity = true; } sText.Append(cNewEntityChar); if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos++]; } else { goto AttributeValueEnd; } continue; } } // check if is end of quotes if (cPeek == cQuotes) { // ok we finished scanning it: add param with value and then go back to param name parsing oChunk.AddParam(sAttrName, sText.SetToString(), cQuotes); if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos]; } else { break; } goto AttributeParsing; } sText.bBuffer[sText.iBufPos++] = cPeek; //sText.Append(cPeek); if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos++]; } else { break; } } oChunk.AddParam(sAttrName, sText.SetToString(), cQuotes); goto ReturnChunk; } } // check if is end of quotes if (cPeek == cQuotes) { // ok we finished scanning it: add param with value and then go back to param name parsing //sText.Clear(); oChunk.AddParam(sAttrName, GetString(iValueStartOffset, iCurPos - iValueStartOffset - 1), cQuotes); if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos]; } else { //iCurPos++; break; } goto AttributeParsing; } if (iCurPos < iDataLength) { cPeek = bHTML[iCurPos++]; } else { //iCurPos++; break; } } AttributeValueEnd: // ok we are done, add outstanding attribute int iLen = iCurPos - iValueStartOffset - 1; if (iLen > 0) { oChunk.AddParam(sAttrName, GetString(iValueStartOffset, iLen), cQuotes); } else { oChunk.AddParam(sAttrName, "", cQuotes); } ReturnChunk: if (oChunk.bClosure) { oChunk.oType = HTMLchunkType.CloseTag; } else { oChunk.oType = HTMLchunkType.OpenTag; } return(oChunk); }
/// <summary> /// Sets oHTML variable in a chunk to the raw HTML that was parsed for that chunk. /// </summary> /// <param name="oChunk">Chunk returned by ParseNext function, it must belong to the same HTMLparser that /// was initiated with the same HTML data that this chunk belongs to</param> public void SetRawHTML(HTMLchunk oChunk) { oChunk.oHTML = oEnc.GetString(bHTML, oChunk.iChunkOffset, oChunk.iChunkLength); }
public int Parse(string content, ArrayList lines) { lines.Clear(); result = lines; HtmlParser parser = new HtmlParser(); parser.SetChunkHashMode(true); parser.Init(content); parser.SetEncoding(System.Text.Encoding.UTF8); HTMLchunk chunk = null; Start(); while (!finished && (chunk = parser.ParseNext()) != null) { switch (chunk.oType) { case HTMLchunkType.OpenTag: HandleTag(chunk); break; case HTMLchunkType.CloseTag: HandleClosure(chunk.sTag); break; case HTMLchunkType.Text: offset = chunk.iChunkOffset; string text = ClearExtraBlanks(chunk.oHTML); text = HTMLentities.DecodeEntities(text); HandleWords(text); break; } } NewLine(true); if (!finished) { TextLine textLine = new TextLine(); /* Raffaele Russo - 19/04/2011 - Start - Modificato l'argomento del costruttore TextSegment, il quarto parametro * da "context.Font.Height" è stato modificato in "context.Font.GetHeight(96)" */ textLine.SetSegments(new ArrayList(line), context.Font.GetHeight(96)); // Raffaele Russo - 19/04/2011 - End textLine.Alignment = context.Alignment; if (height + textLine.Height <= bounds.Height) { result.Add(textLine); } previousLine = null; } byte[] b = new byte[parser.iCurPos]; Array.Copy(parser.bHTML, 0, b, 0, parser.iCurPos); int a = System.Text.Encoding.UTF8.GetString(b).Length; return(a); }
private void HandleTag(HTMLchunk tag) { if (tag.sTag == "b") { Font f = new Font(context.Font.FontFamily, context.Font.Size, context.Font.Style | FontStyle.Bold); Context c = new Context("b", f, context.Color, context.Alignment); stack.Push(context); context = c; } else if (tag.sTag == "i") { Font f = new Font(context.Font.FontFamily, context.Font.Size, context.Font.Style | FontStyle.Italic); Context c = new Context("i", f, context.Color, context.Alignment); stack.Push(context); context = c; } else if (tag.sTag == "div") { if (tag.oParams["align"] != null) { NewLine(false); if (tag.oParams["align"].ToString() == "center") { Context c = new Context("div", context.Font, context.Color, TextField.TextAlignmentType.Center); stack.Push(context); context = c; } else if (tag.oParams["align"].ToString() == "right") { Context c = new Context("div", context.Font, context.Color, TextField.TextAlignmentType.Right); stack.Push(context); context = c; } else if (tag.oParams["align"].ToString() == "justify") { Context c = new Context("div", context.Font, context.Color, TextField.TextAlignmentType.Justified); stack.Push(context); context = c; } else { Context c = new Context("div", context.Font, context.Color, TextField.TextAlignmentType.Left); stack.Push(context); context = c; } } } else if (tag.sTag == "font") { float fontSize = context.Font.Size; string fontFamily = context.Font.FontFamily.Name; FontStyle fontStyle = context.Font.Style; Color color = context.Color; if (tag.oParams["size"] != null) { try { fontSize = ResolveFontSize(tag.oParams["size"].ToString().Trim()); } catch (Exception) {} } if (tag.oParams["face"] != null) { try { fontFamily = tag.oParams["face"].ToString(); } catch (Exception) {} } if (tag.oParams["color"] != null) { try { color = ResolveColor("ff" + tag.oParams["color"].ToString().TrimStart('#')); } catch (Exception) {} } Font f = new Font(fontFamily, fontSize, fontStyle); Context c = new Context("font", f, color, context.Alignment); stack.Push(context); context = c; } else if (tag.sTag == "br") { NewLine(true); } else if (tag.sTag == "p") { NewLine(true); } }