void MarkupAccumulator::appendElement(StringBuilder& result, const Element& element, Namespaces* namespaces)
{
appendOpenTag(result, element, namespaces);
if (element.hasAttributes()) {
for (const Attribute& attribute : element.attributesIterator())
appendAttribute(result, element, attribute, namespaces);
}
// Give an opportunity to subclasses to add their own attributes.
appendCustomAttributes(result, element, namespaces);
appendCloseTag(result, element);
}
void MarkupAccumulator::appendElement(StringBuilder& out, Element* element, Namespaces* namespaces)
{
appendOpenTag(out, element, namespaces);
if (element->hasAttributes()) {
unsigned length = element->attributeCount();
for (unsigned int i = 0; i < length; i++)
appendAttribute(out, element, *element->attributeItem(i), namespaces);
}
// Give an opportunity to subclasses to add their own attributes.
appendCustomAttributes(out, element, namespaces);
appendCloseTag(out, element);
}
void MarkupAccumulator::appendElement(StringBuilder& result, const Element& element, Namespaces* namespaces)
{
appendOpenTag(result, element, namespaces);
if (element.hasAttributes()) {
unsigned length = element.attributeCount();
for (unsigned int i = 0; i < length; i++)
appendAttribute(result, element, element.attributeAt(i), namespaces);
}
// Give an opportunity to subclasses to add their own attributes.
appendCustomAttributes(result, element, namespaces);
appendCloseTag(result, element);
}
void SerializerMarkupAccumulator::appendCustomAttributes(StringBuilder& out, const Element& element, Namespaces* namespaces)
{
if (!is<HTMLFrameOwnerElement>(element))
return;
const HTMLFrameOwnerElement& frameOwner = downcast<HTMLFrameOwnerElement>(element);
Frame* frame = frameOwner.contentFrame();
if (!frame)
return;
URL url = frame->document()->url();
if (url.isValid() && !url.isBlankURL())
return;
// We need to give a fake location to blank frames so they can be referenced by the serialized frame.
url = m_serializer.urlForBlankFrame(frame);
appendAttribute(out, element, Attribute(frameOwnerURLAttributeName(frameOwner), url.string()), namespaces);
}
void SerializerMarkupAccumulator::appendCustomAttributes(StringBuilder& out, Element* element, Namespaces* namespaces)
{
if (!element->isFrameOwnerElement())
return;
HTMLFrameOwnerElement* frameOwner = static_cast<HTMLFrameOwnerElement*>(element);
Frame* frame = frameOwner->contentFrame();
if (!frame)
return;
KURL url = frame->document()->url();
if (url.isValid() && !url.protocolIs("about"))
return;
// We need to give a fake location to blank frames so they can be referenced by the serialized frame.
url = m_serializer->urlForBlankFrame(frame);
appendAttribute(out, element, Attribute(frameOwnerURLAttributeName(*frameOwner), url.string()), namespaces);
}
DbConstIndex::DbConstIndex(const Table &table, const ReadSection &indexSection)
: DbIndex(table.getMetaRecord(), indexSection.at(AtomSize), indexSection.at(2 * AtomSize)),
mTable(table)
{
uint32 numAttributes = indexSection.at(3 * AtomSize);
for (uint32 i = 0; i < numAttributes; i++) {
uint32 attributeId = indexSection.at((4 + i) * AtomSize);
appendAttribute(attributeId);
}
uint32 offset = (4 + numAttributes) * AtomSize;
uint32 numRecords = indexSection.at(offset);
offset += AtomSize;
mKeyOffsetVector.overlay(numRecords,
reinterpret_cast<const Atom *>(indexSection.range(Range(offset, numRecords * AtomSize))));
offset += numRecords * AtomSize;
mRecordNumberVector.overlay(numRecords,
reinterpret_cast<const Atom *>(indexSection.range(Range(offset, numRecords * AtomSize))));
}
//---------------------------------------------------------------
void StreamWriter::startDocument()
{
appendNCNameString ( CSWC::XML_START_ELEMENT );
openElement ( CSWC::CSW_ELEMENT_COLLADA );
if ( getCOLLADAVersion() == COLLADA_1_4_1 )
{
appendAttribute ( CSWC::CSW_ATTRIBUTE_XMLNS, CSWC::CSW_NAMESPACE_1_4_1 );
appendAttribute ( CSWC::CSW_ATTRIBUTE_VERSION, CSWC::CSW_VERSION_1_4_1 );
}
else if ( getCOLLADAVersion() == COLLADA_1_5_0 )
{
appendAttribute ( CSWC::CSW_ATTRIBUTE_XMLNS, CSWC::CSW_NAMESPACE_1_5_0 );
appendAttribute ( CSWC::CSW_ATTRIBUTE_VERSION, CSWC::CSW_VERSION_1_5_0 );
appendAttribute ( CSWC::CSW_ATTRIBUTE_XSI_SCHEMALOCATION, CSWC::CSW_SCHEMALOCATION_1_5_0 );
appendAttribute ( CSWC::CSW_ATTRIBUTE_XMLNS_XSI, CSWC::CSW_XMLNS_XSI_1_5_0 );
}
else
{
COLLADABU_ASSERT(false);
}
}
//[cf]
//[of]:doElement
void DocbookToHTML::doElement(AXElement* e)
{
int level = 2;
bool start = true;
e = e->firstChild;
while( e )
{
switch( e->id )
{
case id_pcdata:
appendAttribute(ax_getAttribute(e, 0));
break;
case id_article:
doElement(e);
break;
case id_chapter:
case id_preface:
case id_section:
case id_simplesect:
{
char buf[1];
buf[0] = '0'+level;
AXElement* title = ax_getElement(e, 0);
append("\n\n<h");
append(buf, 1);
append(">");
appendAttribute(ax_getAttribute(title, 0));
append("</h");
append(buf, 1);
append(">\n\n");
doElement(e);
break;
}
case id_programlisting:
append("<pre>");
appendAttribute(ax_getAttribute(e, 0));
append("</pre>");
break;
case id_itemizedlist:
append("<ul>");
doElement(e);
append("</ul>");
break;
case id_listitem:
append("<li>");
doElement(e);
append("</li>");
break;
case id_para:
case id_note:
if( !start ) append("\n\n<p>");
doElement(e);
if( !start ) append("</p>\n");
start = false;
break;
case id_emphasis:
append("<b>");
doElement(e);
append("</b>");
break;
case id_varname:
case id_guimenuitem:
case id_guimenu:
case id_filename:
case id_code:
append("<tt>");
doElement(e);
append("</tt>");
break;
}
e = e->nextSibling;
}
}
foreach(Attribute * attr, attributes) {
appendAttribute(node, attributeTextItem, attr, state, isReference, isEmpty, itemsList, diffList, isChildrenBlocked);
}
void WebFrameSerializerImpl::openTagToString(
Element* element,
SerializeDomParam* param)
{
bool needSkip;
StringBuilder result;
// Do pre action for open tag.
result.append(preActionBeforeSerializeOpenTag(element, param, &needSkip));
if (needSkip)
return;
// Add open tag
result.append('<');
result.append(element->nodeName().lower());
// Find out if we need to do frame-specific link rewriting.
WebFrame* frame = nullptr;
if (element->isFrameOwnerElement()) {
frame = WebFrame::fromFrame(
toHTMLFrameOwnerElement(element)->contentFrame());
}
WebString rewrittenFrameLink;
bool shouldRewriteFrameSrc =
frame && m_delegate->rewriteFrameSource(frame, &rewrittenFrameLink);
bool didRewriteFrameSrc = false;
// Go through all attributes and serialize them.
for (const auto& it : element->attributes()) {
const QualifiedName& attrName = it.name();
String attrValue = it.value();
// Skip srcdoc attribute if we will emit src attribute (for frames).
if (shouldRewriteFrameSrc && attrName == HTMLNames::srcdocAttr)
continue;
// Rewrite the attribute value if requested.
if (element->hasLegalLinkAttribute(attrName)) {
// For links start with "javascript:", we do not change it.
if (!attrValue.startsWith("javascript:", TextCaseInsensitive)) {
// Get the absolute link.
KURL completeURL = param->document->completeURL(attrValue);
// Check whether we have a local file to link to.
WebString rewrittenURL;
if (shouldRewriteFrameSrc) {
attrValue = rewrittenFrameLink;
didRewriteFrameSrc = true;
} else if (m_delegate->rewriteLink(completeURL, &rewrittenURL)) {
attrValue = rewrittenURL;
} else {
attrValue = completeURL;
}
}
}
appendAttribute(result, param->isHTMLDocument, attrName.toString(), attrValue);
}
// For frames where link rewriting was requested, ensure that src attribute
// is written even if the original document didn't have that attribute
// (mainly needed for iframes with srcdoc, but with no src attribute).
if (shouldRewriteFrameSrc && !didRewriteFrameSrc && isHTMLIFrameElement(element)) {
appendAttribute(
result, param->isHTMLDocument, HTMLNames::srcAttr.toString(), rewrittenFrameLink);
}
// Do post action for open tag.
String addedContents = postActionAfterSerializeOpenTag(element, param);
// Complete the open tag for element when it has child/children.
if (element->hasChildren() || param->haveAddedContentsBeforeEnd)
result.append('>');
// Append the added contents generate in post action of open tag.
result.append(addedContents);
// Save the result to data buffer.
saveHTMLContentToBuffer(result.toString(), param);
}
