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

void FormattingSetting<VerticalTextFormatting>::writeXMLAttributesToStream(XMLSerializer& xml_stream) const
{
    if (d_propertySource.empty())
        xml_stream.attribute("type",
            FalagardXMLHelper<VerticalTextFormatting>::toString(d_value));
    else
        xml_stream.attribute("name", d_propertySource);
}

//----------------------------------------------------------------------------//
void PropertyDim::writeXMLElementAttributes_impl(XMLSerializer& xml_stream) const
{
    if (!d_childName.empty())
        xml_stream.attribute("widget", d_childName);
    xml_stream.attribute("name", d_property);
    if (d_type != DT_INVALID)
        xml_stream.attribute("type", FalagardXMLHelper<DimensionType>::toString(d_type));
}

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

        // write text element
        if (!d_font.empty() && !d_text.empty())
        {
            xml_stream.openTag("Text");
            if (!d_font.empty())
                xml_stream.attribute("font", d_font);
            if (!d_text.empty())
                xml_stream.attribute("string", d_text);
            xml_stream.closeTag();
        }

        // write text property element
        if (!d_textPropertyName.empty())
        {
            xml_stream.openTag("TextProperty")
                .attribute("name", d_textPropertyName)
                .closeTag();
        }

        // write font property element
        if (!d_fontPropertyName.empty())
        {
            xml_stream.openTag("FontProperty")
                .attribute("name", d_fontPropertyName)
                .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::vertTextFormatToString(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::horzTextFormatToString(d_horzFormatting))
                .closeTag();
        }

        // closing tag
        xml_stream.closeTag();
    }

void PropertyDefinitionBase::writeXMLAttributes(XMLSerializer& xml_stream) const
{
    // write the name of the property
    xml_stream.attribute("name", d_name);
    // write initial value, if any
    if (!d_default.empty())
        xml_stream.attribute("initialValue", d_default);
    // write option to redraw when property is written
    if (d_writeCausesRedraw)
        xml_stream.attribute("redrawOnWrite", "true");
    // write option to loayout children when property is written
    if (d_writeCausesLayout)
        xml_stream.attribute("layoutOnWrite", "true");
}

    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();
    }

//----------------------------------------------------------------------------//
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;
}

/*************************************************************************
    Output XML <Image ... > element for this image
*************************************************************************/
void Image::writeXMLToStream(XMLSerializer& xml_stream) const
{
    xml_stream.openTag("Image")
        .attribute("Name", d_name)
        .attribute("XPos", PropertyHelper::uintToString(static_cast<uint>(d_area.d_left)))
        .attribute("YPos", PropertyHelper::uintToString(static_cast<uint>(d_area.d_top)))
        .attribute("Width", PropertyHelper::uintToString(static_cast<uint>(d_area.getWidth())))
        .attribute("Height", PropertyHelper::uintToString(static_cast<uint>(d_area.getHeight())));

    if (d_offset.d_x != 0.0f)
        xml_stream.attribute("XOffset", PropertyHelper::intToString(static_cast<int>(d_offset.d_x)));

    if (d_offset.d_y != 0.0f)
        xml_stream.attribute("YOffset", PropertyHelper::intToString(static_cast<int>(d_offset.d_x)));

    xml_stream.closeTag();
}

//----------------------------------------------------------------------------//
void PropertyDefinitionBase::writeDefinitionXMLAttributes(
                                            XMLSerializer& xml_stream) const
{
    xml_stream.attribute(Falagard_xmlHandler::NameAttribute, d_propertyName);

    if (!d_initialValue.empty())
        xml_stream.attribute(Falagard_xmlHandler::InitialValueAttribute, d_initialValue);

    if (d_writeCausesRedraw)
        xml_stream.attribute(Falagard_xmlHandler::RedrawOnWriteAttribute, PropertyHelper<bool>::ValueTrue);

    if (d_writeCausesLayout)
        xml_stream.attribute(Falagard_xmlHandler::LayoutOnWriteAttribute, PropertyHelper<bool>::ValueTrue);

    if (!d_eventFiredOnWrite.empty())
        xml_stream.attribute(Falagard_xmlHandler::FireEventAttribute, d_eventFiredOnWrite);
}

    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 SectionSpecification::writeXMLToStream(XMLSerializer& xml_stream) const
    {
        xml_stream.openTag("Section");

        if (!d_owner.empty())
            xml_stream.attribute("look", d_owner);

        xml_stream.attribute("section", d_sectionName);

        // render controlling property name if needed
        if (!d_renderControlProperty.empty())
            xml_stream.attribute("controlProperty", d_renderControlProperty);

        if (d_usingColourOverride)
        {
            // output modulative colours for this section
            if (!d_colourPropertyName.empty())
            {
                if (d_colourProperyIsRect)
                    xml_stream.openTag("ColourRectProperty");
                else
                    xml_stream.openTag("ColourProperty");

                xml_stream.attribute("name", d_colourPropertyName)
                    .closeTag();
            }
            else if (!d_coloursOverride.isMonochromatic() || d_coloursOverride.d_top_left != colour(1,1,1,1))
            {
                xml_stream.openTag("Colours")
                    .attribute("topLeft", PropertyHelper::colourToString(d_coloursOverride.d_top_left))
                    .attribute("topRight", PropertyHelper::colourToString(d_coloursOverride.d_top_right))
                    .attribute("bottomLeft", PropertyHelper::colourToString(d_coloursOverride.d_bottom_left))
                    .attribute("bottomRight", PropertyHelper::colourToString(d_coloursOverride.d_bottom_right))
                    .closeTag();
            }

        }
        // close section element 
        xml_stream.closeTag();
    }

    void StateImagery::writeXMLToStream(XMLSerializer& xml_stream) const
    {
        xml_stream.openTag("StateImagery")
            .attribute("name", d_stateName);

        if (d_clipToDisplay)
            xml_stream.attribute("clipped", "false");

        // output all layers defined for this state
        for(LayersList::const_iterator curr = d_layers.begin(); curr != d_layers.end(); ++curr)
            (*curr).writeXMLToStream(xml_stream);
        // write closing </StateImagery> tag
        xml_stream.closeTag();
    }

    void StateImagery::writeXMLToStream(XMLSerializer& xml_stream) const
    {
        xml_stream.openTag(Falagard_xmlHandler::StateImageryElement)
            .attribute(Falagard_xmlHandler::NameAttribute, d_stateName);

        if (d_clipToDisplay)
            xml_stream.attribute(Falagard_xmlHandler::ClippedAttribute, PropertyHelper<bool>::Falsee);

        // output all layers defined for this state
        for(LayersList::const_iterator curr = d_layers.begin(); curr != d_layers.end(); ++curr)
            (*curr).writeXMLToStream(xml_stream);
        // write closing </StateImagery> tag
        xml_stream.closeTag();
    }

    void WidgetComponent::writeXMLToStream(XMLSerializer& xml_stream) const
    {
        // output opening tag
        xml_stream.openTag("Child")
            .attribute("type", d_baseType)
            .attribute("nameSuffix", d_nameSuffix);

        if (!d_imageryName.empty())
            xml_stream.attribute("look", d_imageryName);

        if (!d_rendererType.empty())
            xml_stream.attribute("renderer", d_rendererType);


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

        // output vertical alignment
        xml_stream.openTag("VertAlignment")
            .attribute("type", FalagardXMLHelper::vertAlignmentToString(d_vertAlign))
            .closeTag();

        // output horizontal alignment
        xml_stream.openTag("HorzAlignment")
            .attribute("type", FalagardXMLHelper::horzAlignmentToString(d_horzAlign))
            .closeTag();

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

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

    void LayerSpecification::writeXMLToStream(XMLSerializer& xml_stream) const
    {
        xml_stream.openTag("Layer");

        if (d_layerPriority != 0)
            xml_stream.attribute("priority", PropertyHelper<uint>::toString(d_layerPriority));

        // ouput all sections in this layer
        for(SectionList::const_iterator curr = d_sections.begin(); curr != d_sections.end(); ++curr)
        {
            (*curr).writeXMLToStream(xml_stream);
        }

        xml_stream.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].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();
}