Paragraph Paragraph::rest(){ Node_S * iterator = head->next; Paragraph p = Paragraph(); while(iterator){ p.append(iterator->data); iterator = iterator->next; } return p; }
void MarkupParser::AppendMarkup(const TextDocumentRef& document, const BString& text) { fTextDocument.SetTo(document); fCurrentCharacterStyle = &fNormalStyle; fCurrentParagraphStyle = &fParagraphStyle; fCurrentParagraph = Paragraph(*fCurrentParagraphStyle); fSpanStartOffset = 0; _ParseText(text); fTextDocument.Unset(); }
///////////////////////////////////////////////////////////////////////////////////// /// build the paragraph structure in the DOM tree. /// in the initial, a paragraph has only one sentence. ///////////////////////////////////////////////////////////////////////////////////// int XML4NLP::BuildParagraph(string& strParagraph, int paragraphIdx) { TiXmlElement * documentPtr = document.documentPtr; vector<Paragraph> ¶graphs = document.paragraphs; paragraphs.push_back( Paragraph() ); Paragraph ¶graph = paragraphs[paragraphs.size() - 1]; paragraph.paragraphPtr = new TiXmlElement(TAG_PARA); paragraph.paragraphPtr->SetAttribute(TAG_ID, paragraphIdx); documentPtr->LinkEndChild(paragraph.paragraphPtr); TiXmlText *textPtr = new TiXmlText(strParagraph.c_str()); paragraph.paragraphPtr->LinkEndChild( textPtr ); return 0; }
int XML4NLP::InitXmlParagraph(vector<Paragraph> ¶graphs, TiXmlElement *paragraphPtr) { paragraphs.push_back( Paragraph() ); Paragraph ¶graph = paragraphs[paragraphs.size()-1]; paragraph.paragraphPtr = paragraphPtr; TiXmlElement *stnsPtr = paragraphPtr->FirstChildElement(TAG_SENT); if (stnsPtr == NULL) return 0; // have not split sentence // record the sentence info do { if (0 != InitXmlSentence(paragraph.sentences, stnsPtr)) return -1; stnsPtr = stnsPtr->NextSiblingElement(TAG_SENT); } while(stnsPtr != NULL); return 0; }
PrintOut::PrintOut( QPrinter *printer ) : pr( printer ), nextRule( NoRule ), page( 0 ) { p.begin( pr ); QFont f( QLatin1String("Arial") ); f8 = f; f8.setPointSize( 8 ); f10 = f; f10.setPointSize( 10 ); p.setFont( f10 ); fmetrics = new QFontMetrics( p.fontMetrics() ); hmargin = 5 * printer->width() / printer->widthMM(); // 5 mm vmargin = 5 * printer->height() / printer->heightMM(); // 5 mm hsize = printer->width() - 2 * hmargin; vsize = printer->height() - vmargin; dateTime = QDateTime::currentDateTime(); breakPage(true); // init vsize and draw first header cp = Paragraph( QPoint(hmargin, voffset) ); }
void PrintOut::flushLine(bool /* mayBreak */) { if (voffset + cp.rect.height() > vsize) breakPage(); else if (!firstParagraph) drawRule(nextRule); for (int i = 0; i < cp.boxes.count(); ++i) { Box b = cp.boxes[i]; b.rect.translate(0, voffset); QRect r = b.rect; p.setFont(b.font); p.drawText(r, b.text, b.options); } voffset += cp.rect.height(); nextRule = NoRule; cp = Paragraph(QPoint(hmargin, voffset)); firstParagraph = false; }
void PrintOut::flushLine( bool /* mayBreak */ ) { if ( voffset + cp.rect.height() > vsize ) breakPage(); else if ( !firstParagraph ) drawRule( nextRule ); for ( int i = 0; i < (int) cp.boxes.count(); i++ ) { Box b = cp.boxes[i]; b.rect.moveBy( 0, voffset ); QRect r = b.rect; p.setFont( b.font ); p.drawText( r, b.align, b.text ); } voffset += cp.rect.height(); nextRule = NoRule; cp = Paragraph( QPoint(hmargin, voffset) ); firstParagraph = FALSE; }
PrintOut::PrintOut( QPrinter *printer ) : pr( printer ), pdmetrics( printer ), nextRule( NoRule ), page( 0 ) { p.begin( pr ); QFont f( "Arial" ); f8 = f; f8.setPointSize( 8 ); f10 = f; f10.setPointSize( 10 ); p.setFont( f10 ); fmetrics = new QFontMetrics( p.fontMetrics() ); hmargin = 5 * pdmetrics.width() / pdmetrics.widthMM(); // 5 mm vmargin = 5 * pdmetrics.height() / pdmetrics.heightMM(); // 5 mm hsize = pdmetrics.width() - 2 * hmargin; vsize = pdmetrics.height() - vmargin; dateTime = QDateTime::currentDateTime(); breakPage(); vsize -= voffset; cp = Paragraph( QPoint(hmargin, voffset) ); }
void LLConsole::update() { { LLMutexLock lock(&mMutex); while (!mLines.empty()) { mParagraphs.push_back( Paragraph( mLines.front(), LLColor4::white, mTimer.getElapsedTimeF32(), mFont, (F32)getRect().getWidth())); mLines.pop_front(); } } // remove old paragraphs which can't possibly be visible any more. ::draw() will do something similar but more conservative - we do this here because ::draw() isn't guaranteed to ever be called! (i.e. the console isn't visible) while ((S32)mParagraphs.size() > llmax((S32)0, (S32)(mMaxLines))) { mParagraphs.pop_front(); } }
QList<QPair<QGithubMarkdown::Paragraph, QGithubMarkdown::List> > QGithubMarkdown::listize(const QList<QGithubMarkdown::Paragraph> ¶graphs) { QList<QPair<Paragraph, List>> out; List currentList; auto finishList = [&]() { if (currentList.paragraphs.size() > 0) { out.append(qMakePair(Paragraph(), currentList)); } currentList = List(); }; for (const Paragraph ¶graph : paragraphs) { if (paragraph.type != Paragraph::OrderedList && paragraph.type != Paragraph::UnorderedList) { finishList(); out.append(qMakePair(paragraph, List())); } else { const int indent = (paragraph.indentTokens.size() / 2) + 1; if (currentList.indent != indent || currentList.ordered != (paragraph.type == Paragraph::OrderedList)) { finishList(); currentList.indent = indent; currentList.ordered = (paragraph.type == Paragraph::OrderedList); } currentList.paragraphs.append(paragraph); } } return out; }
status_t TextDocument::Insert(int32 textOffset, const BString& text, const CharacterStyle& characterStyle, const ParagraphStyle& paragraphStyle) { int32 paragraphOffset; int32 index = ParagraphIndexFor(textOffset, paragraphOffset); if (index < 0) return B_BAD_VALUE; textOffset -= paragraphOffset; bool hasLineBreaks = text.FindFirst('\n', 0) >= 0; if (hasLineBreaks) { // Split paragraph at textOffset Paragraph paragraph1(ParagraphAt(index).Style()); Paragraph paragraph2(paragraphStyle); const TextSpanList& textSpans = ParagraphAt(index).TextSpans(); int32 spanCount = textSpans.CountItems(); for (int32 i = 0; i < spanCount; i++) { const TextSpan& span = textSpans.ItemAtFast(i); int32 spanLength = span.CountChars(); if (textOffset >= spanLength) { paragraph1.Append(span); textOffset -= spanLength; } else if (textOffset > 0) { paragraph1.Append( span.SubSpan(0, textOffset)); paragraph2.Append( span.SubSpan(textOffset, spanLength - textOffset)); textOffset = 0; } else { paragraph2.Append(span); } } fParagraphs.Remove(index); // Insert TextSpans, splitting 'text' into Paragraphs at line breaks. int32 length = text.CountChars(); int32 chunkStart = 0; while (chunkStart < length) { int32 chunkEnd = text.FindFirst('\n', chunkStart); bool foundLineBreak = chunkEnd >= chunkStart; if (foundLineBreak) chunkEnd++; else chunkEnd = length; BString chunk; text.CopyCharsInto(chunk, chunkStart, chunkEnd - chunkStart); TextSpan span(chunk, characterStyle); if (foundLineBreak) { if (!paragraph1.Append(span)) return B_NO_MEMORY; if (paragraph1.Length() > 0) { if (!fParagraphs.Add(paragraph1, index)) return B_NO_MEMORY; index++; } paragraph1 = Paragraph(paragraphStyle); } else { if (!paragraph2.Prepend(span)) return B_NO_MEMORY; } chunkStart = chunkEnd + 1; } if (paragraph2.IsEmpty()) { // Make sure Paragraph has at least one TextSpan, even // if its empty. const TextSpanList& spans = paragraph1.TextSpans(); const TextSpan& span = spans.LastItem(); paragraph2.Append(TextSpan("", span.Style())); } if (!fParagraphs.Add(paragraph2, index)) return B_NO_MEMORY; } else { Paragraph paragraph(ParagraphAt(index)); paragraph.Insert(textOffset, TextSpan(text, characterStyle)); if (!fParagraphs.Replace(index, paragraph)) return B_NO_MEMORY; } return B_OK; }
QList<QGithubMarkdown::Paragraph> QGithubMarkdown::paragraphize(const QList<QGithubMarkdown::Token> &tokens) { QList<Paragraph> out; Paragraph currentParagraph; QListIterator<Token> iterator(tokens); auto peekPreviousInternal = [&]() { return iterator.hasPrevious() ? iterator.peekPrevious() : Token(); }; auto peekPrevious = [&]() { const Token previous = peekPreviousInternal(); if (previous.type == Token::Invalid) { return Token(); } iterator.previous(); const Token ret = peekPreviousInternal(); iterator.next(); // don't forget to undo the call to next return ret; }; auto firstNonSpaceOnLine = [&]() { int numTokens = 0; while (peekPrevious().type == Token::Character && peekPrevious().content.toString() == " ") { numTokens++; iterator.previous(); } bool ret = peekPrevious().type == Token::Invalid || peekPrevious().type == Token::NewLine; // roll back while (numTokens > 0) { numTokens--; iterator.next(); } return ret; }; auto nextParagraph = [&]() { if (!currentParagraph.tokens.isEmpty()) { if ((currentParagraph.tokens.last().type == Token::Character && currentParagraph.tokens.last().source == "\n") || currentParagraph.tokens.last().type == Token::NewLine) { currentParagraph.tokens.removeLast(); } if (!currentParagraph.tokens.isEmpty()) { out.append(currentParagraph); } } currentParagraph = Paragraph(); }; QList<Token> spaceTokens; while (iterator.hasNext()) { const Token token = iterator.next(); const bool isFirstNonSpace = firstNonSpaceOnLine(); if (token.type == Token::EOD) { break; } if (isFirstNonSpace && token.type == Token::Character && token.content == ' ') { spaceTokens += token; continue; } if (token.type == Token::NewLine) { spaceTokens.clear(); } if (token.type == Token::NewLine && peekPrevious().type == Token::NewLine) { nextParagraph(); } else if (token.type == Token::CodeDelimiter) { currentParagraph.type = Paragraph::Code; while (iterator.hasNext() && iterator.peekNext().type != Token::CodeDelimiter) { currentParagraph.tokens.append(iterator.next()); } if (iterator.hasNext()) { iterator.next(); // consume code end delimiter } nextParagraph(); } else if (token.type == Token::QuoteStart && isFirstNonSpace) { currentParagraph.type = Paragraph::Quote; } else if (token.type == Token::HeadingStart && isFirstNonSpace) { currentParagraph.type = (Paragraph::Type)token.content.toInt(); } else if (token.type == Token::UnorderedListStart && isFirstNonSpace) { nextParagraph(); currentParagraph.type = Paragraph::UnorderedList; currentParagraph.indentTokens = spaceTokens; } else if (token.type == Token::OrderedListStart && isFirstNonSpace) { nextParagraph(); currentParagraph.type = Paragraph::OrderedList; currentParagraph.indentTokens = spaceTokens; } else if (token.type == Token::NewLine) { Token token; token.type = Token::Character; token.source = '\n'; token.content = QChar(' '); currentParagraph.tokens += token; } else { currentParagraph.tokens += token; } } if (!currentParagraph.tokens.isEmpty()) { out.append(currentParagraph); } return out; }
RTFStatus RTFReader::ParseDocument(RTFToken p_token, int4 p_value) { RTFStatus t_status; t_status = kRTFStatusSuccess; RTFToken t_token; t_token = p_token & kRTFTokenMask; bool t_has_parameter; t_has_parameter = (p_token & kRTFTokenHasParameter) != 0; switch(t_token) { case kRTFTokenSkipDestination: m_state . SetDestination(kRTFDestinationSkip); break; case kRTFTokenFontTable: m_state . SetDestination(kRTFDestinationFontTable); break; case kRTFTokenColorTable: m_state . SetDestination(kRTFDestinationColorTable); break; case kRTFTokenListTable: m_state . SetDestination(kRTFDestinationListTable); break; case kRTFTokenListText: m_list_skip = true; m_state . SetDestination(kRTFDestinationListText); break; case kRTFTokenListOverrideTable: m_state . SetDestination(kRTFDestinationListOverrideTable); break; case kRTFTokenFldInst: m_state . SetDestination(kRTFDestinationFldInst); break; case kRTFTokenField: break; case kRTFTokenDefaultFont: if (t_has_parameter) m_default_font = p_value; break; case kRTFTokenAnsi: m_default_text_encoding = kMCTextEncodingWindows1252; break; case kRTFTokenMac: m_default_text_encoding = kMCTextEncodingMacRoman; break; case kRTFTokenPC: m_default_text_encoding = (MCTextEncoding)(kMCTextEncodingWindowsNative + 437); break; case kRTFTokenPCA: m_default_text_encoding = (MCTextEncoding)(kMCTextEncodingWindowsNative + 850); break; case kRTFTokenAnsiCodepage: if (t_has_parameter) { if (p_value < 0) p_value = 65536 + p_value; m_default_text_encoding = (MCTextEncoding)(kMCTextEncodingWindowsNative + p_value); } break; case kRTFTokenUnicodeSkip: if (t_has_parameter) m_state . SetUnicodeSkip(p_value); break; case kRTFTokenNewLine: case kRTFTokenParagraph: t_status = Flush(true); if (t_status == kRTFStatusSuccess) { if (m_needs_paragraph) Paragraph(); m_needs_paragraph = true; } break; case kRTFTokenResetParagraphStyle: // MW-2012-03-14: [[ RtfParaStyles ]] Reset all the paragraph styles to defaults. m_state . SetListStyle(kMCTextListStyleNone); m_state . SetListLevel(0); m_state . SetListIndex(0); m_state . SetBorderWidth(0); m_state . SetPadding(0); m_state . SetFirstIndent(0); m_state . SetLeftIndent(0); m_state . SetRightIndent(0); m_state . SetSpaceAbove(0); m_state . SetSpaceBelow(0); m_state . SetParagraphBackgroundColor(0xffffffff); m_state . SetBorderColor(0xffffffff); // MW-2014-01-08: [[ Bug 11627 ]] Make sure the text alignment attribute is reset. m_state . SetTextAlign(kMCTextTextAlignLeft); break; case kRTFTokenRow: m_table_cell = false; t_status = Flush(true); if (t_status == kRTFStatusSuccess) { if (m_needs_paragraph) Paragraph(); m_needs_paragraph = true; } break; case kRTFTokenCell: if (m_table_cell) { m_table_cell = false; t_status = m_text . Output(9, kMCTextEncodingUTF16); } if (t_status == kRTFStatusSuccess && m_attributes_changed) t_status = Flush(); if (t_status == kRTFStatusSuccess) m_table_cell = true; break; case kRTFTokenColor: if (t_has_parameter) { m_state . SetForegroundColor(m_colors . Get(p_value)); m_attributes_changed = true; } break; case kRTFTokenHighlight: if (t_has_parameter) { m_state . SetBackgroundColor(m_colors . Get(p_value)); m_attributes_changed = true; } break; case kRTFTokenPlain: m_state . SetFontName(NULL); m_state . SetFontStyle(kRTFFontStyleNone); m_state . SetFontSize(0); m_attributes_changed = true; break; case kRTFTokenFont: if (t_has_parameter) { static struct { int charset; MCTextEncoding encoding; } s_charset_mapping[] = { { ANSI_CHARSET, kMCTextEncodingWindows1252 }, { SYMBOL_CHARSET, kMCTextEncodingSymbol }, { MAC_CHARSET , kMCTextEncodingMacRoman }, { SHIFTJIS_CHARSET, MCTextEncoding(kMCTextEncodingWindowsNative + 932) }, { HANGEUL_CHARSET, MCTextEncoding(kMCTextEncodingWindowsNative + 949) }, { JOHAB_CHARSET, MCTextEncoding(kMCTextEncodingWindowsNative + 1361) }, { GB2312_CHARSET, MCTextEncoding(kMCTextEncodingWindowsNative + 936) }, { CHINESEBIG5_CHARSET, MCTextEncoding(kMCTextEncodingWindowsNative + 950) }, { GREEK_CHARSET, MCTextEncoding(kMCTextEncodingWindowsNative + 1253) }, { TURKISH_CHARSET, MCTextEncoding(kMCTextEncodingWindowsNative + 1254) }, { VIETNAMESE_CHARSET, MCTextEncoding(kMCTextEncodingWindowsNative + 1258) }, { HEBREW_CHARSET, MCTextEncoding(kMCTextEncodingWindowsNative + 1255) }, { ARABIC_CHARSET, MCTextEncoding(kMCTextEncodingWindowsNative + 1256) }, { BALTIC_CHARSET, MCTextEncoding(kMCTextEncodingWindowsNative + 1257) }, { RUSSIAN_CHARSET, MCTextEncoding(kMCTextEncodingWindowsNative + 1251) }, { THAI_CHARSET, MCTextEncoding(kMCTextEncodingWindowsNative + 874) }, { EASTEUROPE_CHARSET, MCTextEncoding(kMCTextEncodingWindowsNative + 1250) }, { /* PC437_CHARSET */ 254, MCTextEncoding(kMCTextEncodingWindowsNative + 437) }, { -1, kMCTextEncodingUndefined } }; const char *t_new_font; t_new_font = m_fonts . GetName(p_value); uint4 t_new_charset; t_new_charset = m_fonts . GetCharset(p_value); MCTextEncoding t_new_encoding; if (t_new_charset == DEFAULT_CHARSET) t_new_encoding = m_default_text_encoding; else { uint4 t_charset_index; for(t_charset_index = 0; s_charset_mapping[t_charset_index] . charset != -1; ++t_charset_index) if (s_charset_mapping[t_charset_index] . charset == t_new_charset) break; t_new_encoding = s_charset_mapping[t_charset_index] . encoding; } m_state . SetTextEncoding(t_new_encoding); m_state . SetFontName(t_new_font); m_attributes_changed = true; } break; case kRTFTokenFontSize: if (t_has_parameter) { m_state . SetFontSize(p_value); m_attributes_changed = true; } break; case kRTFTokenBold: case kRTFTokenItalic: case kRTFTokenUnderline: case kRTFTokenNoUnderline: case kRTFTokenStrikethrough: case kRTFTokenSuperscript: case kRTFTokenSubscript: { bool t_turn_off; t_turn_off = t_has_parameter && p_value == 0; RTFFontStyle t_mask; if (t_token == kRTFTokenBold) t_mask = kRTFFontStyleBold; else if (t_token == kRTFTokenItalic) t_mask = kRTFFontStyleItalic; else if (t_token == kRTFTokenUnderline) t_mask = kRTFFontStyleUnderline; else if (t_token == kRTFTokenNoUnderline) { t_mask = kRTFFontStyleUnderline; t_turn_off = true; } else if (t_token == kRTFTokenStrikethrough) t_mask = kRTFFontStyleStrikethrough; else if (t_token == kRTFTokenSuperscript) t_mask = kRTFFontStyleSuperscript; else if (t_token == kRTFTokenSubscript) t_mask = kRTFFontStyleSubscript; RTFFontStyle t_new_style; if (t_turn_off) t_new_style = m_state . GetFontStyle() & ~t_mask; else t_new_style = m_state . GetFontStyle() | t_mask; m_state . SetFontStyle(t_new_style); m_attributes_changed = true; } break; case kRTFTokenTab: if (t_status == kRTFStatusSuccess && m_table_cell) { m_table_cell = false; t_status = m_text . Output(9, kMCTextEncodingUTF16); } if (m_attributes_changed) t_status = Flush(); if (t_status == kRTFStatusSuccess) t_status = m_text . Output(9, kMCTextEncodingUTF16); break; case kRTFTokenUnicode: { if (t_has_parameter) { if (t_status == kRTFStatusSuccess && m_table_cell) { m_table_cell = false; t_status = m_text . Output(9, kMCTextEncodingUTF16); } if (m_attributes_changed) t_status = Flush(); if (t_status == kRTFStatusSuccess) t_status = m_text . Output(p_value & 0xFFFF, kMCTextEncodingUTF16); if (t_status == kRTFStatusSuccess) m_input_skip_count = m_state . GetUnicodeSkip(); } } break; case kRTFTokenCharacter: { MCTextEncoding t_encoding; t_encoding = m_state . GetTextEncoding(); if (t_encoding == kMCTextEncodingUndefined) t_encoding = m_default_text_encoding; if (t_status == kRTFStatusSuccess && m_table_cell) { m_table_cell = false; t_status = m_text . Output(9, kMCTextEncodingUTF16); } if (m_attributes_changed) t_status = Flush(); if (t_status == kRTFStatusSuccess) t_status = m_text . Output(p_value, t_encoding); } break; // MW-2010-01-08: [[ Bug 8143 ]] Make sure we handle special chars and map then to UTF-16 case kRTFTokenBullet: t_status = m_text . Output(0x2022, kMCTextEncodingUTF16); break; case kRTFTokenLeftQuote: t_status = m_text . Output(0x2018, kMCTextEncodingUTF16); break; case kRTFTokenRightQuote: t_status = m_text . Output(0x2019, kMCTextEncodingUTF16); break; case kRTFTokenLeftDoubleQuote: t_status = m_text . Output(0x201C, kMCTextEncodingUTF16); break; case kRTFTokenRightDoubleQuote: t_status = m_text . Output(0x201D, kMCTextEncodingUTF16); break; // Handle the 'listselect' style lists. case kRTFTokenListSelect: if (t_has_parameter) m_state . SetListIndex(p_value); break; // MW-2012-03-14: [[ RtfParaStyles ]] Handle the list level select. case kRTFTokenListSelectLevel: if (t_has_parameter && p_value >= 0 && p_value <= 8) m_state . SetListLevel(p_value); break; // MW-2012-03-14: [[ RtfParaStyles ]] Handle all the paragraph style tags. case kRTFTokenParagraphBackgroundColor: if (t_has_parameter) m_state . SetParagraphBackgroundColor(m_colors . Get(p_value)); break; case kRTFTokenParagraphBorderWidth: if (t_has_parameter) m_state . SetBorderWidth(p_value); break; case kRTFTokenParagraphBorderColor: if (t_has_parameter) m_state . SetBorderColor(m_colors . Get(p_value)); break; case kRTFTokenParagraphPadding: if (t_has_parameter) m_state . SetPadding(p_value); break; case kRTFTokenLeftIndent: if (t_has_parameter) m_state . SetLeftIndent(p_value); break; case kRTFTokenRightIndent: if (t_has_parameter) m_state . SetRightIndent(p_value); break; case kRTFTokenFirstIndent: if (t_has_parameter) m_state . SetFirstIndent(p_value); break; case kRTFTokenSpaceAbove: if (t_has_parameter) m_state . SetSpaceAbove(p_value); break; case kRTFTokenSpaceBelow: if (t_has_parameter) m_state . SetSpaceBelow(p_value); break; case kRTFTokenLeftJustify: m_state . SetTextAlign(kMCTextTextAlignLeft); break; case kRTFTokenRightJustify: m_state . SetTextAlign(kMCTextTextAlignRight); break; case kRTFTokenCenterJustify: m_state . SetTextAlign(kMCTextTextAlignCenter); break; } return t_status; }
RTFStatus RTFReader::Flush(bool p_force) { RTFStatus t_status; t_status = kRTFStatusSuccess; if (!m_attributes_changed && !p_force) return t_status; MCTextBlock t_block; bool t_changed; t_changed = false; if (m_attributes_changed) { t_block . foreground_color = m_state . GetForegroundColor(); t_block . background_color = m_state . GetBackgroundColor(); t_block . font_name = m_state . GetFontName(); if (m_state . GetFontSize() != 0) t_block . font_size = half_points_to_pixels(m_state . GetFontSize()); else t_block . font_size = 0; t_block . font_style = FA_DEFAULT_STYLE; if ((m_state . GetFontStyle() & kRTFFontStyleItalic) != 0) t_block . font_style |= FA_ITALIC; if ((m_state . GetFontStyle() & kRTFFontStyleBold) != 0) t_block . font_style |= FA_BOLD; if ((m_state . GetFontStyle() & kRTFFontStyleUnderline) != 0) t_block . font_style |= FA_UNDERLINE; if ((m_state . GetFontStyle() & kRTFFontStyleStrikethrough) != 0) t_block . font_style |= FA_STRIKEOUT; if ((m_state . GetFontStyle() & kRTFFontStyleLink) != 0) t_block . font_style |= FA_LINK; if ((m_state . GetFontStyle() & kRTFFontStyleSuperscript) != 0) t_block . text_shift = -4; else if ((m_state . GetFontStyle() & kRTFFontStyleSubscript) != 0) t_block . text_shift = 4; else t_block . text_shift = 0; if (m_state . GetHyperlink() != kMCEmptyName) MCNameClone(m_state . GetHyperlink(), t_block . text_link); else t_block . text_link = nil; if (m_state . GetMetadata() != kMCEmptyName) MCNameClone(m_state . GetMetadata(), t_block . text_metadata); else t_block . text_metadata = nil; t_block . string_native = false; t_block . string_buffer = NULL; t_block . string_length = 0; if (t_block . foreground_color != m_attributes . foreground_color || t_block . background_color != m_attributes . background_color || t_block . font_size != m_attributes . font_size || t_block . font_style != m_attributes . font_style || t_block . text_shift != m_attributes . text_shift || CStringCompare(t_block . font_name, m_attributes . font_name) != 0 || t_block . text_link != m_attributes . text_link || t_block . text_metadata != m_attributes . text_metadata) t_changed = true; } const uint2 *t_string_buffer; uint4 t_string_length; if (t_status == kRTFStatusSuccess) t_status = m_text . Borrow(t_string_buffer, t_string_length); if (t_status == kRTFStatusSuccess && t_string_length > 0 && (t_changed || p_force)) { if (m_needs_paragraph) { m_needs_paragraph = false; // MW-2012-03-14: [[ RtfParaStyles ]] Use the 'Paragraph()' method to ensure // paragraph styles get applied. Paragraph(); } m_attributes . string_native = false; m_attributes . string_buffer = t_string_buffer; m_attributes . string_length = t_string_length / 2; m_converter(m_converter_context, NULL, &m_attributes); m_text . Clear(); } if (t_changed) { MCNameDelete(m_attributes . text_metadata); MCNameDelete(m_attributes . text_link); memcpy(&m_attributes, &t_block, sizeof(MCTextBlock)); m_attributes_changed = false; } return t_status; }
/* ** Break markup is any kind of markup that might force a line-break. This ** routine handles a single element of break markup and returns a pointer ** to the first element past that markup. If p doesn't point to break ** markup, then p is returned. If p is an incomplete table (a <TABLE> ** that lacks a </TABLE>), then NULL is returned. */ static HtmlElement *DoBreakMarkup( HtmlLayoutContext *pLC, HtmlElement *p ){ HtmlElement *pNext = p->pNext; char *z; int x, y, w; switch( p->base.type ){ case Html_A: p->anchor.y = pLC->bottom; TestPoint(0); break; case Html_BLOCKQUOTE: HtmlPushMargin(&pLC->leftMargin, HTML_INDENT, -1, Html_EndBLOCKQUOTE); HtmlPushMargin(&pLC->rightMargin, HTML_INDENT, -1, Html_EndBLOCKQUOTE); Paragraph(pLC, p); TestPoint(0); break; case Html_EndBLOCKQUOTE: HtmlPopMargin(&pLC->leftMargin, Html_EndBLOCKQUOTE, pLC); HtmlPopMargin(&pLC->rightMargin, Html_EndBLOCKQUOTE, pLC); Paragraph(pLC, p); TestPoint(0); break; case Html_IMG: switch( p->image.align ){ case IMAGE_ALIGN_Left: HtmlComputeMargins(pLC, &x, &y, &w); p->image.x = x; p->image.y = y; p->image.ascent = 0; p->image.descent = p->image.h; HtmlPushMargin(&pLC->leftMargin, p->image.w + 2, y + p->image.h, 0); SETMAX( pLC->maxY, y + p->image.h ); SETMAX( pLC->maxX, x + p->image.w ); break; case IMAGE_ALIGN_Right: HtmlComputeMargins(pLC, &x, &y, &w); p->image.x = x + w - p->image.w; p->image.y = y; p->image.ascent = 0; p->image.descent = p->image.h; HtmlPushMargin(&pLC->rightMargin, p->image.w + 2, y + p->image.h, 0); SETMAX( pLC->maxY, y + p->image.h ); SETMAX( pLC->maxX, x + p->image.w ); break; default: TestPoint(0); pNext = p; break; } break; case Html_PRE: /* Skip space tokens thru the next newline. */ while( pNext->base.type==Html_Space ){ HtmlElement *pThis = pNext; pNext = pNext->pNext; if( pThis->base.flags & HTML_NewLine ){ TestPoint(0); break; } } Paragraph(pLC,p); break; case Html_UL: case Html_MENU: case Html_DIR: case Html_OL: if( p->list.compact==0 ){ Paragraph(pLC,p); } HtmlPushMargin(&pLC->leftMargin, HTML_INDENT, -1, p->base.type+1); break; case Html_EndOL: case Html_EndUL: case Html_EndMENU: case Html_EndDIR: if( p->ref.pOther ){ HtmlPopMargin(&pLC->leftMargin, p->base.type, pLC); if( !p->ref.pOther->list.compact ){ Paragraph(pLC,p); } } break; case Html_DL: Paragraph(pLC,p); HtmlPushMargin(&pLC->leftMargin, HTML_INDENT, -1, Html_EndDL); TestPoint(0); break; case Html_EndDL: HtmlPopMargin(&pLC->leftMargin, Html_EndDL, pLC); Paragraph(pLC,p); TestPoint(0); break; case Html_HR: { int zl, wd; p->hr.is3D = HtmlMarkupArg(p, "noshade", 0)==0; z = HtmlMarkupArg(p, "size", 0); if( z ){ p->hr.h = atoi(z); }else{ p->hr.h = 0; } if( p->hr.h<1 ){ int relief = pLC->htmlPtr->ruleRelief; if( p->hr.is3D && (relief==TK_RELIEF_SUNKEN || relief==TK_RELIEF_RAISED) ){ p->hr.h = 3; }else{ p->hr.h = 2; } } HtmlComputeMargins(pLC, &x, &y, &w); p->hr.y = y; y += p->hr.h + 1; p->hr.x = x; z = HtmlMarkupArg(p, "width", "100%"); zl = strlen(z); if( zl>0 && z[zl-1]=='%' ){ wd = (atoi(z)*w)/100; }else{ wd = atoi(z); } if( wd>w ) wd = w; p->hr.w = wd; switch( p->base.style.align ){ case ALIGN_Center: case ALIGN_None: p->hr.x += (w - wd)/2; TestPoint(0); break; case ALIGN_Right: p->hr.x += (w - wd); TestPoint(0); break; default: TestPoint(0); break; } SETMAX( pLC->maxY, y); SETMAX( pLC->maxX, wd + p->hr.x ); pLC->bottom = y; pLC->headRoom = 0; break; } case Html_ADDRESS: case Html_EndADDRESS: case Html_CENTER: case Html_EndCENTER: case Html_DIV: case Html_EndDIV: case Html_H1: case Html_EndH1: case Html_H2: case Html_EndH2: case Html_H3: case Html_EndH3: case Html_H4: case Html_EndH4: case Html_H5: case Html_EndH5: case Html_H6: case Html_EndH6: case Html_P: case Html_EndP: case Html_EndPRE: Paragraph(pLC, p); TestPoint(0); break; case Html_TABLE: pNext = HtmlTableLayout(pLC, p); TestPoint(0); break; case Html_BR: z = HtmlMarkupArg(p, "clear",0); if( z ){ if( stricmp(z,"left")==0 ){ ClearObstacle(pLC, CLEAR_Left); TestPoint(0); }else if( stricmp(z,"right")==0 ){ ClearObstacle(pLC, CLEAR_Right); TestPoint(0); }else{ ClearObstacle(pLC, CLEAR_Both); TestPoint(0); } }else{ TestPoint(0); } break; /* All of the following tags need to be handed to the GetLine() routine */ case Html_Text: case Html_Space: case Html_LI: case Html_INPUT: case Html_SELECT: case Html_TEXTAREA: case Html_APPLET: case Html_EMBED: pNext = p; TestPoint(0); break; default: TestPoint(0); break; } return pNext; }