Quelle  attribute.cxx   Sprache: unbekannt

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#include <mathml/attribute.hxx>

void SmMlAttribute::clearPreviousAttributeValue()
{
    switch (m_aSmMlAttributeValueType)
    {
        case SmMlAttributeValueType::NMlEmpty:
            break;
        case SmMlAttributeValueType::MlHref:
            if (m_aAttributeValue.m_aHref.m_aLnk)
                delete m_aAttributeValue.m_aHref.m_aLnk;
            break;
        case SmMlAttributeValueType::MlLspace:
            if (m_aAttributeValue.m_aLspace.m_aLengthValue.m_aOriginalText)
                delete m_aAttributeValue.m_aLspace.m_aLengthValue.m_aOriginalText;
            break;
        case SmMlAttributeValueType::MlMathsize:
            if (m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aOriginalText)
                delete m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aOriginalText;
            break;
        case SmMlAttributeValueType::MlMaxsize:
            if (m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aOriginalText)
                delete m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aOriginalText;
            break;
        case SmMlAttributeValueType::MlMinsize:
            if (m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aOriginalText)
                delete m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aOriginalText;
            break;
        case SmMlAttributeValueType::MlRspace:
            if (m_aAttributeValue.m_aRspace.m_aLengthValue.m_aOriginalText)
                delete m_aAttributeValue.m_aRspace.m_aLengthValue.m_aOriginalText;
            break;
        default:
            break;
    }
}

void SmMlAttribute::setDefaultAttributeValue()
{
    switch (m_aSmMlAttributeValueType)
    {
        case SmMlAttributeValueType::NMlEmpty:
            break;
        case SmMlAttributeValueType::MlAccent:
            m_aAttributeValue.m_aAccent.m_aAccent = SmMlAttributeValueAccent::MlFalse;
            break;
        case SmMlAttributeValueType::MlDir:
            m_aAttributeValue.m_aDir.m_aDir = SmMlAttributeValueDir::MlLtr;
            break;
        case SmMlAttributeValueType::MlDisplaystyle:
            m_aAttributeValue.m_aDisplaystyle.m_aDisplaystyle
                = SmMlAttributeValueDisplaystyle::MlFalse;
            break;
        case SmMlAttributeValueType::MlFence:
            m_aAttributeValue.m_aFence.m_aFence = SmMlAttributeValueFence::MlFalse;
            break;
        case SmMlAttributeValueType::MlForm:
            m_aAttributeValue.m_aForm.m_aForm = SmMlAttributeValueForm::MlInfix;
            break;
        case SmMlAttributeValueType::MlHref:
            m_aAttributeValue.m_aHref.m_aHref = SmMlAttributeValueHref::NMlEmpty;
            m_aAttributeValue.m_aHref.m_aLnk = new OUString(u""_ustr);
            break;
        case SmMlAttributeValueType::MlLspace:
            m_aAttributeValue.m_aLspace.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlEm;
            m_aAttributeValue.m_aLspace.m_aLengthValue.m_aLengthValue = 5.0 / 18;
            m_aAttributeValue.m_aLspace.m_aLengthValue.m_aOriginalText
                = new OUString(u"5/18em"_ustr);
            break;
        case SmMlAttributeValueType::MlMathbackground:
            m_aAttributeValue.m_aMathbackground.m_aMathbackground
                = SmMlAttributeValueMathbackground::MlTransparent;
            break;
        case SmMlAttributeValueType::MlMathcolor:
            m_aAttributeValue.m_aMathcolor.m_aMathcolor = SmMlAttributeValueMathcolor::MlDefault;
            break;
        case SmMlAttributeValueType::MlMathsize:
            m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlP;
            m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aLengthValue = 100;
            m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aOriginalText
                = new OUString(u"100%"_ustr);
            break;
        case SmMlAttributeValueType::MlMathvariant:
            m_aAttributeValue.m_aMathvariant.m_aMathvariant = SmMlAttributeValueMathvariant::normal;
            break;
        case SmMlAttributeValueType::MlMaxsize:
            m_aAttributeValue.m_aMaxsize.m_aMaxsize = SmMlAttributeValueMaxsize::MlInfinity;
            m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlP;
            m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aLengthValue = 10000;
            m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aOriginalText
                = new OUString(u"10000%"_ustr);
            break;
        case SmMlAttributeValueType::MlMinsize:
            m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlP;
            m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aLengthValue = 1;
            m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aOriginalText = new OUString(u"1%"_ustr);
            break;
        case SmMlAttributeValueType::MlMovablelimits:
            m_aAttributeValue.m_aMovablelimits.m_aMovablelimits
                = SmMlAttributeValueMovablelimits::MlFalse;
            break;
        case SmMlAttributeValueType::MlRspace:
            m_aAttributeValue.m_aRspace.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlEm;
            m_aAttributeValue.m_aRspace.m_aLengthValue.m_aLengthValue = 5.0 / 18;
            m_aAttributeValue.m_aRspace.m_aLengthValue.m_aOriginalText
                = new OUString(u"5/18em"_ustr);
            break;
        case SmMlAttributeValueType::MlSeparator:
            m_aAttributeValue.m_aSeparator.m_aSeparator = SmMlAttributeValueSeparator::MlFalse;
            break;
        case SmMlAttributeValueType::MlStretchy:
            m_aAttributeValue.m_aStretchy.m_aStretchy = SmMlAttributeValueStretchy::MlFalse;
            break;
        case SmMlAttributeValueType::MlSymmetric:
            m_aAttributeValue.m_aSymmetric.m_aSymmetric = SmMlAttributeValueSymmetric::MlFalse;
            break;
    }
}

void SmMlAttribute::setAttributeValue(const SmMlAttribute* aAttribute)
{
    switch (aAttribute->getMlAttributeValueType())
    {
        case SmMlAttributeValueType::NMlEmpty:
            clearPreviousAttributeValue();
            m_aSmMlAttributeValueType = SmMlAttributeValueType::NMlEmpty;
            break;
        case SmMlAttributeValueType::MlAccent:
            setMlAccent(aAttribute->getMlAccent());
            break;
        case SmMlAttributeValueType::MlDir:
            setMlDir(aAttribute->getMlDir());
            break;
        case SmMlAttributeValueType::MlDisplaystyle:
            setMlDisplaystyle(aAttribute->getMlDisplaystyle());
            break;
        case SmMlAttributeValueType::MlFence:
            setMlFence(aAttribute->getMlFence());
            break;
        case SmMlAttributeValueType::MlForm:
            setMlForm(aAttribute->getMlForm());
            break;
        case SmMlAttributeValueType::MlHref:
            setMlHref(aAttribute->getMlHref());
            break;
        case SmMlAttributeValueType::MlLspace:
            setMlLspace(aAttribute->getMlLspace());
            break;
        case SmMlAttributeValueType::MlMathbackground:
            setMlMathbackground(aAttribute->getMlMathbackground());
            break;
        case SmMlAttributeValueType::MlMathcolor:
            setMlMathcolor(aAttribute->getMlMathcolor());
            break;
        case SmMlAttributeValueType::MlMathsize:
            setMlMathsize(aAttribute->getMlMathsize());
            break;
        case SmMlAttributeValueType::MlMathvariant:
            setMlMathvariant(aAttribute->getMlMathvariant());
            break;
        case SmMlAttributeValueType::MlMaxsize:
            setMlMaxsize(aAttribute->getMlMaxsize());
            break;
        case SmMlAttributeValueType::MlMinsize:
            setMlMinsize(aAttribute->getMlMinsize());
            break;
        case SmMlAttributeValueType::MlMovablelimits:
            setMlMovablelimits(aAttribute->getMlMovablelimits());
            break;
        case SmMlAttributeValueType::MlRspace:
            setMlRspace(aAttribute->getMlRspace());
            break;
        case SmMlAttributeValueType::MlSeparator:
            setMlSeparator(aAttribute->getMlSeparator());
            break;
        case SmMlAttributeValueType::MlStretchy:
            setMlStretchy(aAttribute->getMlStretchy());
            break;
        case SmMlAttributeValueType::MlSymmetric:
            setMlSymmetric(aAttribute->getMlSymmetric());
            break;
    }
}

/* get values */
/*************************************************************************************************/

const struct SmMlAccent* SmMlAttribute::getMlAccent() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlAccent)
        return &m_aAttributeValue.m_aAccent;
    return nullptr;
}

const struct SmMlDir* SmMlAttribute::getMlDir() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlDir)
        return &m_aAttributeValue.m_aDir;
    return nullptr;
}

const struct SmMlDisplaystyle* SmMlAttribute::getMlDisplaystyle() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlDisplaystyle)
        return &m_aAttributeValue.m_aDisplaystyle;
    return nullptr;
}

const struct SmMlFence* SmMlAttribute::getMlFence() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlFence)
        return &m_aAttributeValue.m_aFence;
    return nullptr;
}

const struct SmMlForm* SmMlAttribute::getMlForm() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlForm)
        return &m_aAttributeValue.m_aForm;
    return nullptr;
}

const struct SmMlHref* SmMlAttribute::getMlHref() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlHref)
        return &m_aAttributeValue.m_aHref;
    return nullptr;
}

const struct SmMlLspace* SmMlAttribute::getMlLspace() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlLspace)
        return &m_aAttributeValue.m_aLspace;
    return nullptr;
}

const struct SmMlMathbackground* SmMlAttribute::getMlMathbackground() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMathbackground)
        return &m_aAttributeValue.m_aMathbackground;
    return nullptr;
}

const struct SmMlMathcolor* SmMlAttribute::getMlMathcolor() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMathcolor)
        return &m_aAttributeValue.m_aMathcolor;
    return nullptr;
}

const struct SmMlMathsize* SmMlAttribute::getMlMathsize() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlAccent)
        return &m_aAttributeValue.m_aMathsize;
    return nullptr;
}

const struct SmMlMathvariant* SmMlAttribute::getMlMathvariant() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMathvariant)
        return &m_aAttributeValue.m_aMathvariant;
    return nullptr;
}

const struct SmMlMaxsize* SmMlAttribute::getMlMaxsize() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMaxsize)
        return &m_aAttributeValue.m_aMaxsize;
    return nullptr;
}

const struct SmMlMinsize* SmMlAttribute::getMlMinsize() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMinsize)
        return &m_aAttributeValue.m_aMinsize;
    return nullptr;
}

const struct SmMlMovablelimits* SmMlAttribute::getMlMovablelimits() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMovablelimits)
        return &m_aAttributeValue.m_aMovablelimits;
    return nullptr;
}

const struct SmMlRspace* SmMlAttribute::getMlRspace() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlRspace)
        return &m_aAttributeValue.m_aRspace;
    return nullptr;
}

const struct SmMlSeparator* SmMlAttribute::getMlSeparator() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlSeparator)
        return &m_aAttributeValue.m_aSeparator;
    return nullptr;
}

const struct SmMlStretchy* SmMlAttribute::getMlStretchy() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlStretchy)
        return &m_aAttributeValue.m_aStretchy;
    return nullptr;
}

const struct SmMlSymmetric* SmMlAttribute::getMlSymmetric() const
{
    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlSymmetric)
        return &m_aAttributeValue.m_aSymmetric;
    return nullptr;
}

/* set values */
/*************************************************************************************************/

void SmMlAttribute::setMlAccent(const SmMlAccent* aAccent)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aAccent.m_aAccent = aAccent->m_aAccent;
}

void SmMlAttribute::setMlDir(const SmMlDir* aDir)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aDir.m_aDir = aDir->m_aDir;
}

void SmMlAttribute::setMlDisplaystyle(const SmMlDisplaystyle* aDisplaystyle)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aDisplaystyle.m_aDisplaystyle = aDisplaystyle->m_aDisplaystyle;
}

void SmMlAttribute::setMlFence(const SmMlFence* aFence)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aFence.m_aFence = aFence->m_aFence;
}

void SmMlAttribute::setMlForm(const SmMlForm* aForm)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aForm.m_aForm = aForm->m_aForm;
}

void SmMlAttribute::setMlHref(const SmMlHref* aHref)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aHref.m_aHref = aHref->m_aHref;
    m_aAttributeValue.m_aHref.m_aLnk = new OUString(*aHref->m_aLnk);
}

void SmMlAttribute::setMlLspace(const SmMlLspace* aLspace)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aLspace.m_aLengthValue.m_aLengthUnit
        = aLspace->m_aLengthValue.m_aLengthUnit;
    m_aAttributeValue.m_aLspace.m_aLengthValue.m_aLengthValue
        = aLspace->m_aLengthValue.m_aLengthValue;
    m_aAttributeValue.m_aLspace.m_aLengthValue.m_aOriginalText
        = new OUString(*aLspace->m_aLengthValue.m_aOriginalText);
}

void SmMlAttribute::setMlMathbackground(const SmMlMathbackground* aMathbackground)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aMathbackground.m_aMathbackground = aMathbackground->m_aMathbackground;
}

void SmMlAttribute::setMlMathcolor(const SmMlMathcolor* aMathcolor)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aMathcolor.m_aMathcolor = aMathcolor->m_aMathcolor;
}

void SmMlAttribute::setMlMathsize(const SmMlMathsize* aMathsize)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aLengthUnit
        = aMathsize->m_aLengthValue.m_aLengthUnit;
    m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aLengthValue
        = aMathsize->m_aLengthValue.m_aLengthValue;
    m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aOriginalText
        = new OUString(*aMathsize->m_aLengthValue.m_aOriginalText);
}

void SmMlAttribute::setMlMathvariant(const SmMlMathvariant* aMathvariant)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aMathvariant.m_aMathvariant = aMathvariant->m_aMathvariant;
}

void SmMlAttribute::setMlMaxsize(const SmMlMaxsize* aMaxsize)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aMaxsize.m_aMaxsize = aMaxsize->m_aMaxsize;
    m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aLengthUnit
        = aMaxsize->m_aLengthValue.m_aLengthUnit;
    m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aLengthValue
        = aMaxsize->m_aLengthValue.m_aLengthValue;
    m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aOriginalText
        = new OUString(*aMaxsize->m_aLengthValue.m_aOriginalText);
}

void SmMlAttribute::setMlMinsize(const SmMlMinsize* aMinsize)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aLengthUnit
        = aMinsize->m_aLengthValue.m_aLengthUnit;
    m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aLengthValue
        = aMinsize->m_aLengthValue.m_aLengthValue;
    m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aOriginalText
        = new OUString(*aMinsize->m_aLengthValue.m_aOriginalText);
}

void SmMlAttribute::setMlMovablelimits(const SmMlMovablelimits* aMovablelimits)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aMovablelimits.m_aMovablelimits = aMovablelimits->m_aMovablelimits;
}

void SmMlAttribute::setMlRspace(const SmMlRspace* aRspace)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aRspace.m_aLengthValue.m_aLengthUnit
        = aRspace->m_aLengthValue.m_aLengthUnit;
    m_aAttributeValue.m_aRspace.m_aLengthValue.m_aLengthValue
        = aRspace->m_aLengthValue.m_aLengthValue;
    m_aAttributeValue.m_aRspace.m_aLengthValue.m_aOriginalText
        = new OUString(*aRspace->m_aLengthValue.m_aOriginalText);
}

void SmMlAttribute::setMlSeparator(const SmMlSeparator* aSeparator)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aSeparator.m_aSeparator = aSeparator->m_aSeparator;
}

void SmMlAttribute::setMlStretchy(const SmMlStretchy* aStretchy)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aStretchy.m_aStretchy = aStretchy->m_aStretchy;
}

void SmMlAttribute::setMlSymmetric(const SmMlSymmetric* aSymmetric)
{
    m_bSet = true;
    clearPreviousAttributeValue();
    m_aAttributeValue.m_aSymmetric.m_aSymmetric = aSymmetric->m_aSymmetric;
}

/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */