479 lines
18 KiB
C++
479 lines
18 KiB
C++
/* -*- 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: */
|