starmath/source/mathml/attribute.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <mathml/attribute.hxx>
  11
  12 void SmMlAttribute::clearPreviousAttributeValue()
  13 {
  14     switch (m_aSmMlAttributeValueType)
  15     {
  16         case SmMlAttributeValueType::NMlEmpty:
  17             break;
  18         case SmMlAttributeValueType::MlHref:
  19             if (m_aAttributeValue.m_aHref.m_aLnk)
  20                 delete m_aAttributeValue.m_aHref.m_aLnk;
  21             break;
  22         case SmMlAttributeValueType::MlLspace:
  23             if (m_aAttributeValue.m_aLspace.m_aLengthValue.m_aOriginalText)
  24                 delete m_aAttributeValue.m_aLspace.m_aLengthValue.m_aOriginalText;
  25             break;
  26         case SmMlAttributeValueType::MlMathsize:
  27             if (m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aOriginalText)
  28                 delete m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aOriginalText;
  29             break;
  30         case SmMlAttributeValueType::MlMaxsize:
  31             if (m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aOriginalText)
  32                 delete m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aOriginalText;
  33             break;
  34         case SmMlAttributeValueType::MlMinsize:
  35             if (m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aOriginalText)
  36                 delete m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aOriginalText;
  37             break;
  38         case SmMlAttributeValueType::MlRspace:
  39             if (m_aAttributeValue.m_aRspace.m_aLengthValue.m_aOriginalText)
  40                 delete m_aAttributeValue.m_aRspace.m_aLengthValue.m_aOriginalText;
  41             break;
  42         default:
  43             break;
  44     }
  45 }
  46
  47 void SmMlAttribute::setDefaultAttributeValue()
  48 {
  49     switch (m_aSmMlAttributeValueType)
  50     {
  51         case SmMlAttributeValueType::NMlEmpty:
  52             break;
  53         case SmMlAttributeValueType::MlAccent:
  54             m_aAttributeValue.m_aAccent.m_aAccent = SmMlAttributeValueAccent::MlFalse;
  55             break;
  56         case SmMlAttributeValueType::MlDir:
  57             m_aAttributeValue.m_aDir.m_aDir = SmMlAttributeValueDir::MlLtr;
  58             break;
  59         case SmMlAttributeValueType::MlDisplaystyle:
  60             m_aAttributeValue.m_aDisplaystyle.m_aDisplaystyle
  61                 = SmMlAttributeValueDisplaystyle::MlFalse;
  62             break;
  63         case SmMlAttributeValueType::MlFence:
  64             m_aAttributeValue.m_aFence.m_aFence = SmMlAttributeValueFence::MlFalse;
  65             break;
  66         case SmMlAttributeValueType::MlForm:
  67             m_aAttributeValue.m_aForm.m_aForm = SmMlAttributeValueForm::MlInfix;
  68             break;
  69         case SmMlAttributeValueType::MlHref:
  70             m_aAttributeValue.m_aHref.m_aHref = SmMlAttributeValueHref::NMlEmpty;
  71             m_aAttributeValue.m_aHref.m_aLnk = new OUString(u"");
  72             break;
  73         case SmMlAttributeValueType::MlLspace:
  74             m_aAttributeValue.m_aLspace.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlEm;
  75             m_aAttributeValue.m_aLspace.m_aLengthValue.m_aLengthValue = 5.0 / 18;
  76             m_aAttributeValue.m_aLspace.m_aLengthValue.m_aOriginalText = new OUString(u"5/18em");
  77             break;
  78         case SmMlAttributeValueType::MlMathbackground:
  79             m_aAttributeValue.m_aMathbackground.m_aMathbackground
  80                 = SmMlAttributeValueMathbackground::MlTransparent;
  81             break;
  82         case SmMlAttributeValueType::MlMathcolor:
  83             m_aAttributeValue.m_aMathcolor.m_aMathcolor = SmMlAttributeValueMathcolor::MlDefault;
  84             break;
  85         case SmMlAttributeValueType::MlMathsize:
  86             m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlP;
  87             m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aLengthValue = 100;
  88             m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aOriginalText = new OUString(u"100%");
  89             break;
  90         case SmMlAttributeValueType::MlMathvariant:
  91             m_aAttributeValue.m_aMathvariant.m_aMathvariant = SmMlAttributeValueMathvariant::normal;
  92             break;
  93         case SmMlAttributeValueType::MlMaxsize:
  94             m_aAttributeValue.m_aMaxsize.m_aMaxsize = SmMlAttributeValueMaxsize::MlInfinity;
  95             m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlP;
  96             m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aLengthValue = 10000;
  97             m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aOriginalText = new OUString(u"10000%");
  98             break;
  99         case SmMlAttributeValueType::MlMinsize:
 100             m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlP;
 101             m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aLengthValue = 1;
 102             m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aOriginalText = new OUString(u"1%");
 103             break;
 104         case SmMlAttributeValueType::MlMovablelimits:
 105             m_aAttributeValue.m_aMovablelimits.m_aMovablelimits
 106                 = SmMlAttributeValueMovablelimits::MlFalse;
 107             break;
 108         case SmMlAttributeValueType::MlRspace:
 109             m_aAttributeValue.m_aRspace.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlEm;
 110             m_aAttributeValue.m_aRspace.m_aLengthValue.m_aLengthValue = 5.0 / 18;
 111             m_aAttributeValue.m_aRspace.m_aLengthValue.m_aOriginalText = new OUString(u"5/18em");
 112             break;
 113         case SmMlAttributeValueType::MlSeparator:
 114             m_aAttributeValue.m_aSeparator.m_aSeparator = SmMlAttributeValueSeparator::MlFalse;
 115             break;
 116         case SmMlAttributeValueType::MlStretchy:
 117             m_aAttributeValue.m_aStretchy.m_aStretchy = SmMlAttributeValueStretchy::MlFalse;
 118             break;
 119         case SmMlAttributeValueType::MlSymmetric:
 120             m_aAttributeValue.m_aSymmetric.m_aSymmetric = SmMlAttributeValueSymmetric::MlFalse;
 121             break;
 122     }
 123 }
 124
 125 void SmMlAttribute::setAttributeValue(const SmMlAttribute* aAttribute)
 126 {
 127     switch (aAttribute->getMlAttributeValueType())
 128     {
 129         case SmMlAttributeValueType::NMlEmpty:
 130             clearPreviousAttributeValue();
 131             m_aSmMlAttributeValueType = SmMlAttributeValueType::NMlEmpty;
 132             break;
 133         case SmMlAttributeValueType::MlAccent:
 134             setMlAccent(aAttribute->getMlAccent());
 135             break;
 136         case SmMlAttributeValueType::MlDir:
 137             setMlDir(aAttribute->getMlDir());
 138             break;
 139         case SmMlAttributeValueType::MlDisplaystyle:
 140             setMlDisplaystyle(aAttribute->getMlDisplaystyle());
 141             break;
 142         case SmMlAttributeValueType::MlFence:
 143             setMlFence(aAttribute->getMlFence());
 144             break;
 145         case SmMlAttributeValueType::MlForm:
 146             setMlForm(aAttribute->getMlForm());
 147             break;
 148         case SmMlAttributeValueType::MlHref:
 149             setMlHref(aAttribute->getMlHref());
 150             break;
 151         case SmMlAttributeValueType::MlLspace:
 152             setMlLspace(aAttribute->getMlLspace());
 153             break;
 154         case SmMlAttributeValueType::MlMathbackground:
 155             setMlMathbackground(aAttribute->getMlMathbackground());
 156             break;
 157         case SmMlAttributeValueType::MlMathcolor:
 158             setMlMathcolor(aAttribute->getMlMathcolor());
 159             break;
 160         case SmMlAttributeValueType::MlMathsize:
 161             setMlMathsize(aAttribute->getMlMathsize());
 162             break;
 163         case SmMlAttributeValueType::MlMathvariant:
 164             setMlMathvariant(aAttribute->getMlMathvariant());
 165             break;
 166         case SmMlAttributeValueType::MlMaxsize:
 167             setMlMaxsize(aAttribute->getMlMaxsize());
 168             break;
 169         case SmMlAttributeValueType::MlMinsize:
 170             setMlMinsize(aAttribute->getMlMinsize());
 171             break;
 172         case SmMlAttributeValueType::MlMovablelimits:
 173             setMlMovablelimits(aAttribute->getMlMovablelimits());
 174             break;
 175         case SmMlAttributeValueType::MlRspace:
 176             setMlRspace(aAttribute->getMlRspace());
 177             break;
 178         case SmMlAttributeValueType::MlSeparator:
 179             setMlSeparator(aAttribute->getMlSeparator());
 180             break;
 181         case SmMlAttributeValueType::MlStretchy:
 182             setMlStretchy(aAttribute->getMlStretchy());
 183             break;
 184         case SmMlAttributeValueType::MlSymmetric:
 185             setMlSymmetric(aAttribute->getMlSymmetric());
 186             break;
 187     }
 188 }
 189
 190 /* get values */
 191 /*************************************************************************************************/
 192
 193 const struct SmMlAccent* SmMlAttribute::getMlAccent() const
 194 {
 195     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlAccent)
 196         return &m_aAttributeValue.m_aAccent;
 197     return nullptr;
 198 }
 199
 200 const struct SmMlDir* SmMlAttribute::getMlDir() const
 201 {
 202     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlDir)
 203         return &m_aAttributeValue.m_aDir;
 204     return nullptr;
 205 }
 206
 207 const struct SmMlDisplaystyle* SmMlAttribute::getMlDisplaystyle() const
 208 {
 209     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlDisplaystyle)
 210         return &m_aAttributeValue.m_aDisplaystyle;
 211     return nullptr;
 212 }
 213
 214 const struct SmMlFence* SmMlAttribute::getMlFence() const
 215 {
 216     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlFence)
 217         return &m_aAttributeValue.m_aFence;
 218     return nullptr;
 219 }
 220
 221 const struct SmMlForm* SmMlAttribute::getMlForm() const
 222 {
 223     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlForm)
 224         return &m_aAttributeValue.m_aForm;
 225     return nullptr;
 226 }
 227
 228 const struct SmMlHref* SmMlAttribute::getMlHref() const
 229 {
 230     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlHref)
 231         return &m_aAttributeValue.m_aHref;
 232     return nullptr;
 233 }
 234
 235 const struct SmMlLspace* SmMlAttribute::getMlLspace() const
 236 {
 237     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlLspace)
 238         return &m_aAttributeValue.m_aLspace;
 239     return nullptr;
 240 }
 241
 242 const struct SmMlMathbackground* SmMlAttribute::getMlMathbackground() const
 243 {
 244     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMathbackground)
 245         return &m_aAttributeValue.m_aMathbackground;
 246     return nullptr;
 247 }
 248
 249 const struct SmMlMathcolor* SmMlAttribute::getMlMathcolor() const
 250 {
 251     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMathcolor)
 252         return &m_aAttributeValue.m_aMathcolor;
 253     return nullptr;
 254 }
 255
 256 const struct SmMlMathsize* SmMlAttribute::getMlMathsize() const
 257 {
 258     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlAccent)
 259         return &m_aAttributeValue.m_aMathsize;
 260     return nullptr;
 261 }
 262
 263 const struct SmMlMathvariant* SmMlAttribute::getMlMathvariant() const
 264 {
 265     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMathvariant)
 266         return &m_aAttributeValue.m_aMathvariant;
 267     return nullptr;
 268 }
 269
 270 const struct SmMlMaxsize* SmMlAttribute::getMlMaxsize() const
 271 {
 272     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMaxsize)
 273         return &m_aAttributeValue.m_aMaxsize;
 274     return nullptr;
 275 }
 276
 277 const struct SmMlMinsize* SmMlAttribute::getMlMinsize() const
 278 {
 279     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMinsize)
 280         return &m_aAttributeValue.m_aMinsize;
 281     return nullptr;
 282 }
 283
 284 const struct SmMlMovablelimits* SmMlAttribute::getMlMovablelimits() const
 285 {
 286     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMovablelimits)
 287         return &m_aAttributeValue.m_aMovablelimits;
 288     return nullptr;
 289 }
 290
 291 const struct SmMlRspace* SmMlAttribute::getMlRspace() const
 292 {
 293     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlRspace)
 294         return &m_aAttributeValue.m_aRspace;
 295     return nullptr;
 296 }
 297
 298 const struct SmMlSeparator* SmMlAttribute::getMlSeparator() const
 299 {
 300     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlSeparator)
 301         return &m_aAttributeValue.m_aSeparator;
 302     return nullptr;
 303 }
 304
 305 const struct SmMlStretchy* SmMlAttribute::getMlStretchy() const
 306 {
 307     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlStretchy)
 308         return &m_aAttributeValue.m_aStretchy;
 309     return nullptr;
 310 }
 311
 312 const struct SmMlSymmetric* SmMlAttribute::getMlSymmetric() const
 313 {
 314     if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlSymmetric)
 315         return &m_aAttributeValue.m_aSymmetric;
 316     return nullptr;
 317 }
 318
 319 /* set values */
 320 /*************************************************************************************************/
 321
 322 void SmMlAttribute::setMlAccent(const SmMlAccent* aAccent)
 323 {
 324     m_bSet = true;
 325     clearPreviousAttributeValue();
 326     m_aAttributeValue.m_aAccent.m_aAccent = aAccent->m_aAccent;
 327 }
 328
 329 void SmMlAttribute::setMlDir(const SmMlDir* aDir)
 330 {
 331     m_bSet = true;
 332     clearPreviousAttributeValue();
 333     m_aAttributeValue.m_aDir.m_aDir = aDir->m_aDir;
 334 }
 335
 336 void SmMlAttribute::setMlDisplaystyle(const SmMlDisplaystyle* aDisplaystyle)
 337 {
 338     m_bSet = true;
 339     clearPreviousAttributeValue();
 340     m_aAttributeValue.m_aDisplaystyle.m_aDisplaystyle = aDisplaystyle->m_aDisplaystyle;
 341 }
 342
 343 void SmMlAttribute::setMlFence(const SmMlFence* aFence)
 344 {
 345     m_bSet = true;
 346     clearPreviousAttributeValue();
 347     m_aAttributeValue.m_aFence.m_aFence = aFence->m_aFence;
 348 }
 349
 350 void SmMlAttribute::setMlForm(const SmMlForm* aForm)
 351 {
 352     m_bSet = true;
 353     clearPreviousAttributeValue();
 354     m_aAttributeValue.m_aForm.m_aForm = aForm->m_aForm;
 355 }
 356
 357 void SmMlAttribute::setMlHref(const SmMlHref* aHref)
 358 {
 359     m_bSet = true;
 360     clearPreviousAttributeValue();
 361     m_aAttributeValue.m_aHref.m_aHref = aHref->m_aHref;
 362     m_aAttributeValue.m_aHref.m_aLnk = new OUString(*aHref->m_aLnk);
 363 }
 364
 365 void SmMlAttribute::setMlLspace(const SmMlLspace* aLspace)
 366 {
 367     m_bSet = true;
 368     clearPreviousAttributeValue();
 369     m_aAttributeValue.m_aLspace.m_aLengthValue.m_aLengthUnit
 370         = aLspace->m_aLengthValue.m_aLengthUnit;
 371     m_aAttributeValue.m_aLspace.m_aLengthValue.m_aLengthValue
 372         = aLspace->m_aLengthValue.m_aLengthValue;
 373     m_aAttributeValue.m_aLspace.m_aLengthValue.m_aOriginalText
 374         = new OUString(*aLspace->m_aLengthValue.m_aOriginalText);
 375 }
 376
 377 void SmMlAttribute::setMlMathbackground(const SmMlMathbackground* aMathbackground)
 378 {
 379     m_bSet = true;
 380     clearPreviousAttributeValue();
 381     m_aAttributeValue.m_aMathbackground.m_aMathbackground = aMathbackground->m_aMathbackground;
 382 }
 383
 384 void SmMlAttribute::setMlMathcolor(const SmMlMathcolor* aMathcolor)
 385 {
 386     m_bSet = true;
 387     clearPreviousAttributeValue();
 388     m_aAttributeValue.m_aMathcolor.m_aMathcolor = aMathcolor->m_aMathcolor;
 389 }
 390
 391 void SmMlAttribute::setMlMathsize(const SmMlMathsize* aMathsize)
 392 {
 393     m_bSet = true;
 394     clearPreviousAttributeValue();
 395     m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aLengthUnit
 396         = aMathsize->m_aLengthValue.m_aLengthUnit;
 397     m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aLengthValue
 398         = aMathsize->m_aLengthValue.m_aLengthValue;
 399     m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aOriginalText
 400         = new OUString(*aMathsize->m_aLengthValue.m_aOriginalText);
 401 }
 402
 403 void SmMlAttribute::setMlMathvariant(const SmMlMathvariant* aMathvariant)
 404 {
 405     m_bSet = true;
 406     clearPreviousAttributeValue();
 407     m_aAttributeValue.m_aMathvariant.m_aMathvariant = aMathvariant->m_aMathvariant;
 408 }
 409
 410 void SmMlAttribute::setMlMaxsize(const SmMlMaxsize* aMaxsize)
 411 {
 412     m_bSet = true;
 413     clearPreviousAttributeValue();
 414     m_aAttributeValue.m_aMaxsize.m_aMaxsize = aMaxsize->m_aMaxsize;
 415     m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aLengthUnit
 416         = aMaxsize->m_aLengthValue.m_aLengthUnit;
 417     m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aLengthValue
 418         = aMaxsize->m_aLengthValue.m_aLengthValue;
 419     m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aOriginalText
 420         = new OUString(*aMaxsize->m_aLengthValue.m_aOriginalText);
 421 }
 422
 423 void SmMlAttribute::setMlMinsize(const SmMlMinsize* aMinsize)
 424 {
 425     m_bSet = true;
 426     clearPreviousAttributeValue();
 427     m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aLengthUnit
 428         = aMinsize->m_aLengthValue.m_aLengthUnit;
 429     m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aLengthValue
 430         = aMinsize->m_aLengthValue.m_aLengthValue;
 431     m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aOriginalText
 432         = new OUString(*aMinsize->m_aLengthValue.m_aOriginalText);
 433 }
 434
 435 void SmMlAttribute::setMlMovablelimits(const SmMlMovablelimits* aMovablelimits)
 436 {
 437     m_bSet = true;
 438     clearPreviousAttributeValue();
 439     m_aAttributeValue.m_aMovablelimits.m_aMovablelimits = aMovablelimits->m_aMovablelimits;
 440 }
 441
 442 void SmMlAttribute::setMlRspace(const SmMlRspace* aRspace)
 443 {
 444     m_bSet = true;
 445     clearPreviousAttributeValue();
 446     m_aAttributeValue.m_aRspace.m_aLengthValue.m_aLengthUnit
 447         = aRspace->m_aLengthValue.m_aLengthUnit;
 448     m_aAttributeValue.m_aRspace.m_aLengthValue.m_aLengthValue
 449         = aRspace->m_aLengthValue.m_aLengthValue;
 450     m_aAttributeValue.m_aRspace.m_aLengthValue.m_aOriginalText
 451         = new OUString(*aRspace->m_aLengthValue.m_aOriginalText);
 452 }
 453
 454 void SmMlAttribute::setMlSeparator(const SmMlSeparator* aSeparator)
 455 {
 456     m_bSet = true;
 457     clearPreviousAttributeValue();
 458     m_aAttributeValue.m_aSeparator.m_aSeparator = aSeparator->m_aSeparator;
 459 }
 460
 461 void SmMlAttribute::setMlStretchy(const SmMlStretchy* aStretchy)
 462 {
 463     m_bSet = true;
 464     clearPreviousAttributeValue();
 465     m_aAttributeValue.m_aStretchy.m_aStretchy = aStretchy->m_aStretchy;
 466 }
 467
 468 void SmMlAttribute::setMlSymmetric(const SmMlSymmetric* aSymmetric)
 469 {
 470     m_bSet = true;
 471     clearPreviousAttributeValue();
 472     m_aAttributeValue.m_aSymmetric.m_aSymmetric = aSymmetric->m_aSymmetric;
 473 }
 474
 475 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */