C++ XMLSerializer::openTag方法代码示例

void FormattingSetting<VerticalFormatting>::writeXMLTagToStream(XMLSerializer& xml_stream) const
{
    if (d_propertySource.empty())
        xml_stream.openTag("VertFormat");
    else
        xml_stream.openTag("VertFormatProperty");
}

//----------------------------------------------------------------------------//
void ComponentArea::writeXMLToStream(XMLSerializer& xml_stream) const
{
    xml_stream.openTag("Area");

    // see if we should write an AreaProperty element
    if (isAreaFetchedFromProperty())
    {
        xml_stream.openTag("AreaProperty")
            .attribute("name", d_namedSource)
            .closeTag();
    }
    else if (isAreaFetchedFromNamedArea())
    {
        xml_stream.openTag("NamedAreaSource")
            .attribute("look", d_namedAreaSourceLook)
            .attribute("name", d_namedSource)
            .closeTag();
    }
    // not a property, write out individual dimensions explicitly.
    else
    {
        d_left.writeXMLToStream(xml_stream);
        d_top.writeXMLToStream(xml_stream);
        d_right_or_width.writeXMLToStream(xml_stream);
        d_bottom_or_height.writeXMLToStream(xml_stream);
    }
    xml_stream.closeTag();
}

//----------------------------------------------------------------------------//
bool FalagardComponentBase::writeColoursXML(XMLSerializer& xml_stream) const
{

    if (!d_colourPropertyName.empty())
    {
        xml_stream.openTag("ColourRectProperty");
        xml_stream.attribute("name", d_colourPropertyName)
            .closeTag();
    }
    else if (!d_colours.isMonochromatic() ||
              d_colours.d_top_left != Colour(1,1,1,1))
    {
        xml_stream.openTag("Colours")
            .attribute("topLeft",
                PropertyHelper<Colour>::toString(d_colours.d_top_left))
            .attribute("topRight",
                PropertyHelper<Colour>::toString(d_colours.d_top_right))
            .attribute("bottomLeft",
                PropertyHelper<Colour>::toString(d_colours.d_bottom_left))
            .attribute("bottomRight",
                PropertyHelper<Colour>::toString(d_colours.d_bottom_right))
            .closeTag();
    }
    else
        return false;

    return true;
}

//----------------------------------------------------------------------------//
void FrameComponent::writeXMLToStream(XMLSerializer& xml_stream) const
{
    // opening tag
    xml_stream.openTag("FrameComponent");
    // write out area
    d_area.writeXMLToStream(xml_stream);

    // write images
    for (int i = 0; i < FIC_FRAME_IMAGE_COUNT; ++i)
    {
        if (d_frameImages[i].d_specified)
        {
            if (d_frameImages[i].d_propertyName.empty())
                xml_stream.openTag("Image")
                    .attribute("name", d_frameImages[i].d_image->getName())
                    .attribute("component", FalagardXMLHelper<FrameImageComponent>::toString(static_cast<FrameImageComponent>(i)))
                    .closeTag();
            else
                xml_stream.openTag("ImageProperty")
                    .attribute("name", d_frameImages[i].d_propertyName)
                    .attribute("component", FalagardXMLHelper<FrameImageComponent>::toString(static_cast<FrameImageComponent>(i)))
                    .closeTag();
        }
    }

    // get base class to write colours
    writeColoursXML(xml_stream);

    d_backgroundVertFormatting.writeXMLTagToStream(xml_stream);
    d_backgroundVertFormatting.writeXMLAttributesToStream(xml_stream);
    xml_stream.attribute("component", "Background").closeTag();

    d_leftEdgeFormatting.writeXMLTagToStream(xml_stream);
    d_leftEdgeFormatting.writeXMLAttributesToStream(xml_stream);
    xml_stream.attribute("component", "LeftEdge").closeTag();

    d_rightEdgeFormatting.writeXMLTagToStream(xml_stream);
    d_rightEdgeFormatting.writeXMLAttributesToStream(xml_stream);
    xml_stream.attribute("component", "RightEdge").closeTag();

    d_backgroundHorzFormatting.writeXMLTagToStream(xml_stream);
    d_backgroundHorzFormatting.writeXMLAttributesToStream(xml_stream);
    xml_stream.attribute("component", "Background").closeTag();

    d_topEdgeFormatting.writeXMLTagToStream(xml_stream);
    d_topEdgeFormatting.writeXMLAttributesToStream(xml_stream);
    xml_stream.attribute("component", "TopEdge").closeTag();

    d_bottomEdgeFormatting.writeXMLTagToStream(xml_stream);
    d_bottomEdgeFormatting.writeXMLAttributesToStream(xml_stream);
    xml_stream.attribute("component", "BottomEdge").closeTag();

    // closing tag
    xml_stream.closeTag();
}

    void WidgetComponent::writeXMLToStream(XMLSerializer& xml_stream) const
    {
        // output opening tag
        xml_stream.openTag(Falagard_xmlHandler::ChildElement)
            .attribute(Falagard_xmlHandler::NameSuffixAttribute, d_name)
            .attribute(Falagard_xmlHandler::TypeAttribute, d_targetType);

        if (!d_rendererType.empty())
            xml_stream.attribute(Falagard_xmlHandler::RendererAttribute, d_rendererType);

        if (!d_autoWindow)
            xml_stream.attribute(Falagard_xmlHandler::AutoWindowAttribute, PropertyHelper<bool>::False);

        // Output <EventAction> elements
        for (EventActionList::const_iterator i = d_eventActions.begin();
                i != d_eventActions.end();
                ++i)
        {
            (*i).writeXMLToStream(xml_stream);
        }

        // output target area
        d_area.writeXMLToStream(xml_stream);

        // output vertical alignment if not-default
        if(d_vertAlign != VerticalAlignmentDefault)
        {
            xml_stream.openTag(Falagard_xmlHandler::VertAlignmentElement);
            xml_stream.attribute(Falagard_xmlHandler::TypeAttribute, FalagardXMLHelper<VerticalAlignment>::toString(d_vertAlign));
            xml_stream.closeTag();
        }

        // output horizontal alignment if not-default
        if(d_horzAlign != HorizontalAlignmentDefault)
        {
            xml_stream.openTag(Falagard_xmlHandler::HorzAlignmentElement);
            xml_stream.attribute(Falagard_xmlHandler::TypeAttribute, FalagardXMLHelper<HorizontalAlignment>::toString(d_horzAlign));
            xml_stream.closeTag();
        }

        //output property initialisers
        for (PropertyInitialiserList::const_iterator prop = d_propertyInitialisers.begin(); prop != d_propertyInitialisers.end(); ++prop)
        {
            (*prop).writeXMLToStream(xml_stream);
        }

        // output closing tag
        xml_stream.closeTag();
    }

//----------------------------------------------------------------------------//
void Font::writeXMLToStream(XMLSerializer& xml_stream) const
{
    // output starting <Font ... > element
    xml_stream.openTag("Font")
        .attribute(Font_xmlHandler::FontNameAttribute, d_name)
        .attribute(Font_xmlHandler::FontFilenameAttribute, d_filename);

    if (!d_resourceGroup.empty())
        xml_stream.attribute(Font_xmlHandler::FontResourceGroupAttribute,
                             d_resourceGroup);

    if (d_nativeResolution.d_width != DefaultNativeHorzRes)
        xml_stream.attribute(Font_xmlHandler::FontNativeHorzResAttribute,
            PropertyHelper<uint>::toString(static_cast<uint>(d_nativeResolution.d_width)));

    if (d_nativeResolution.d_height != DefaultNativeVertRes)
        xml_stream.attribute(Font_xmlHandler::FontNativeVertResAttribute,
            PropertyHelper<uint>::toString(static_cast<uint>(d_nativeResolution.d_height)));

    if (d_autoScaled != ASM_Disabled)
        xml_stream.attribute(Font_xmlHandler::FontAutoScaledAttribute,
            PropertyHelper<AutoScaledMode>::toString(d_autoScaled));

    writeXMLToStream_impl(xml_stream);

    // output closing </Font> element.
    xml_stream.closeTag();
}

//----------------------------------------------------------------------------//
void EventAction::writeXMLToStream(XMLSerializer& xml_stream) const
{
    xml_stream.openTag("EventAction")
        .attribute("event", d_eventName)
        .attribute("action", FalagardXMLHelper<ChildEventAction>::toString(d_action))
        .closeTag();
}

 void NamedArea::writeXMLToStream(XMLSerializer& xml_stream) const
 {
     xml_stream.openTag("NamedArea")
         .attribute("name", d_name);
     d_area.writeXMLToStream(xml_stream);
     xml_stream.closeTag();
 }

 void PropertyInitialiser::writeXMLToStream(XMLSerializer& xml_stream) const
 {
     xml_stream.openTag("Property")
         .attribute("name", d_propertyName)
         .attribute("value", d_propertyValue)
         .closeTag();
 }

void Imageset::writeXMLToStream(XMLSerializer& xml_stream) const
{
    // output Imageset tag
    xml_stream.openTag("Imageset")
        .attribute("Name", d_name)
        .attribute("Imagefile", d_textureFilename);

    if (d_nativeHorzRes != DefaultNativeHorzRes)
        xml_stream.attribute("NativeHorzRes", 
          PropertyHelper::uintToString(static_cast<uint>(d_nativeHorzRes)));
    if (d_nativeVertRes != DefaultNativeVertRes)
        xml_stream.attribute("NativeVertRes", 
          PropertyHelper::uintToString(static_cast<uint>(d_nativeVertRes)));

    if (d_autoScale)
        xml_stream.attribute("AutoScaled", "true");

    // output images
    ImageIterator image = getIterator();
    while (!image.isAtEnd())
    {
        image.getCurrentValue().writeXMLToStream(xml_stream);
        ++image;
    }

    // output closing tag
    xml_stream.closeTag();
}

 void PropertyInitialiser::writeXMLToStream(XMLSerializer& xml_stream) const
 {
     xml_stream.openTag(Falagard_xmlHandler::PropertyElement)
         .attribute(Falagard_xmlHandler::NameAttribute, d_propertyName)
         .attribute(Falagard_xmlHandler::ValueAttribute, d_propertyValue)
         .closeTag();
 }

    void FrameComponent::writeXMLToStream(XMLSerializer& xml_stream) const
    {
        // opening tag
        xml_stream.openTag("FrameComponent");
        // write out area
        d_area.writeXMLToStream(xml_stream);

        // write images
        for (int i = 0; i < FIC_FRAME_IMAGE_COUNT; ++i)
        {
            if (d_frameImages[i])
            {
                xml_stream.openTag("Image")
                    .attribute("imageset", d_frameImages[i]->getImagesetName())
                    .attribute("image", d_frameImages[i]->getName())
                    .attribute("type", FalagardXMLHelper::frameImageComponentToString(static_cast<FrameImageComponent>(i)))
                    .closeTag();
            }
        }

        // get base class to write colours
        writeColoursXML(xml_stream);

        // write vert format, allowing base class to do this for us if a propety is in use
        if (!writeVertFormatXML(xml_stream))
        {
            // was not a property, so write out explicit formatting in use
            xml_stream.openTag("VertFormat")
                .attribute("type", FalagardXMLHelper::vertFormatToString(d_vertFormatting))
                .closeTag();

        }

        // write horz format, allowing base class to do this for us if a propety is in use
        if (!writeHorzFormatXML(xml_stream))
        {
            // was not a property, so write out explicit formatting in use
            xml_stream.openTag("HorzFormat")
                .attribute("type", FalagardXMLHelper::horzFormatToString(d_horzFormatting))
                .closeTag();
        }

        // closing tag
        xml_stream.closeTag();
    }

    void ImagerySection::writeXMLToStream(XMLSerializer& xml_stream) const
    {
        // output opening tag
        xml_stream.openTag("ImagerySection")
            .attribute("name", d_name);

        // output modulative colours for this section
        if (!d_colourPropertyName.empty())
        {
            xml_stream.openTag("ColourRectProperty");
            xml_stream.attribute("name", d_colourPropertyName)
                .closeTag();
        }
        else if (!d_masterColours.isMonochromatic() || d_masterColours.d_top_left != Colour(1,1,1,1))
        {
            xml_stream.openTag("Colours")
                .attribute("topLeft", PropertyHelper<Colour>::toString(d_masterColours.d_top_left))
                .attribute("topRight", PropertyHelper<Colour>::toString(d_masterColours.d_top_right))
                .attribute("bottomLeft", PropertyHelper<Colour>::toString(d_masterColours.d_bottom_left))
                .attribute("bottomRight", PropertyHelper<Colour>::toString(d_masterColours.d_bottom_right))
                .closeTag();
        }

        // output all frame components.
        for(FrameList::const_iterator frame = d_frames.begin(); frame != d_frames.end(); ++frame)
        {
            (*frame).writeXMLToStream(xml_stream);
        }

        // output all imagery components
        for(ImageryList::const_iterator image = d_images.begin(); image != d_images.end(); ++image)
        {
            (*image).writeXMLToStream(xml_stream);
        }

        // output all text components
        for(TextList::const_iterator text = d_texts.begin(); text != d_texts.end(); ++text)
        {
            (*text).writeXMLToStream(xml_stream);
        }

        // output closing tag
        xml_stream.closeTag();
    }

    void TextComponent::writeXMLToStream(XMLSerializer& xml_stream) const
    {
        // opening tag
        xml_stream.openTag(Falagard_xmlHandler::TextComponentElement);
        // write out area
        d_area.writeXMLToStream(xml_stream);

        // write text element
        if (!d_font.empty() || !getText().empty())
        {
            xml_stream.openTag(Falagard_xmlHandler::TextElement);
            if (!d_font.empty())
                xml_stream.attribute(Falagard_xmlHandler::FontAttribute, d_font);
            if (!getText().empty())
                xml_stream.attribute(Falagard_xmlHandler::StringAttribute, getText());
            xml_stream.closeTag();
        }

        // write text property element
        if (!d_textPropertyName.empty())
        {
            xml_stream.openTag(Falagard_xmlHandler::TextPropertyElement)
                .attribute(Falagard_xmlHandler::NameAttribute, d_textPropertyName)
                .closeTag();
        }

        // write font property element
        if (!d_fontPropertyName.empty())
        {
            xml_stream.openTag(Falagard_xmlHandler::FontPropertyElement)
                .attribute(Falagard_xmlHandler::NameAttribute, d_fontPropertyName)
                .closeTag();
        }

        // get base class to write colours
        writeColoursXML(xml_stream);

        d_vertFormatting.writeXMLToStream(xml_stream);
        d_horzFormatting.writeXMLToStream(xml_stream);

        // closing tag
        xml_stream.closeTag();
    }

    void ImageryComponent::writeXMLToStream(XMLSerializer& xml_stream) const
    {
        // opening tag
        xml_stream.openTag("ImageryComponent");
        // write out area
        d_area.writeXMLToStream(xml_stream);

        // write image
        if (isImageFetchedFromProperty())
            xml_stream.openTag("ImageProperty")
                .attribute("name", d_imagePropertyName)
                .closeTag();
        else
            xml_stream.openTag("Image")
                .attribute("imageset", d_image->getImagesetName())
                .attribute("image", d_image->getName())
                .closeTag();

        // get base class to write colours
        writeColoursXML(xml_stream);

        // write vert format, allowing base class to do this for us if a propety is in use
        if (!writeVertFormatXML(xml_stream))
        {
            // was not a property, so write out explicit formatting in use
            xml_stream.openTag("VertFormat")
                .attribute("type", FalagardXMLHelper::vertFormatToString(d_vertFormatting))
                .closeTag();
        }

        // write horz format, allowing base class to do this for us if a propety is in use
        if (!writeHorzFormatXML(xml_stream))
        {
            // was not a property, so write out explicit formatting in use
            xml_stream.openTag("HorzFormat")
                .attribute("type", FalagardXMLHelper::horzFormatToString(d_horzFormatting))
                .closeTag();
        }

        // closing tag
        xml_stream.closeTag();
    }