starmath: Convert SmNodeType to scoped enum

Change-Id: I30921f9426e0e50ab8c6dfb1e86400847176b707
Reviewed-on: https://gerrit.libreoffice.org/36613
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Takeshi Abe <tabe@fixedpoint.jp>

3 files changed, 64 insertions, 64 deletions

diff --git a/starmath/qa/cppunit/mock-visitor.hxx b/starmath/qa/cppunit/mock-visitor.hxx
index b3ed74803cbe..ca13e16e569c 100644
--- a/starmath/qa/cppunit/mock-visitor.hxx
+++ b/starmath/qa/cppunit/mock-visitor.hxx
@@ -20,8 +20,8 @@ public:
     virtual ~MockVisitor() {}
 
     void Visit( SmTableNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmTableNode should have type NTABLE",
-                                     NTABLE, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmTableNode should have type SmNodeType::Table",
+                                     SmNodeType::Table, pNode->GetType());
         auto eTT = pNode->GetToken().eType;
         CPPUNIT_ASSERT_MESSAGE("The type of SmTableNode's token should be either TEND, TBINOM, or TSTACK",
                                eTT == TEND || eTT == TBINOM || eTT == TSTACK);
@@ -29,150 +29,150 @@ public:
     }
 
     void Visit( SmBraceNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmBraceNode should have type NBRACE",
-                                     NBRACE, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmBraceNode should have type SmNodeType::Brace",
+                                     SmNodeType::Brace, pNode->GetType());
         VisitChildren( pNode );
     }
 
     void Visit( SmBracebodyNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmBracebodyNode should have type NBRACEBODY",
-                                     NBRACEBODY, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmBracebodyNode should have type SmNodeType::Bracebody",
+                                     SmNodeType::Bracebody, pNode->GetType());
         VisitChildren( pNode );
     }
 
     void Visit( SmOperNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmOperNode should have type NOPER",
-                                     NOPER, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmOperNode should have type SmNodeType::Oper",
+                                     SmNodeType::Oper, pNode->GetType());
         VisitChildren( pNode );
     }
 
     void Visit( SmAlignNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmAlignNode should have type NALIGN",
-                                     NALIGN, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmAlignNode should have type SmNodeType::Align",
+                                     SmNodeType::Align, pNode->GetType());
         VisitChildren( pNode );
     }
 
     void Visit( SmAttributNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmAttributNode should have type NATTRIBUT",
-                                     NATTRIBUT, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmAttributNode should have type SmNodeType::Attribut",
+                                     SmNodeType::Attribut, pNode->GetType());
         VisitChildren( pNode );
     }
 
     void Visit( SmFontNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmFontNode should have type NFONT",
-                                     NFONT, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmFontNode should have type SmNodeType::Font",
+                                     SmNodeType::Font, pNode->GetType());
         VisitChildren( pNode );
     }
 
     void Visit( SmUnHorNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmUnHorNode should have type NUNHOR",
-                                     NUNHOR, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmUnHorNode should have type SmNodeType::UnHor",
+                                     SmNodeType::UnHor, pNode->GetType());
         VisitChildren( pNode );
     }
 
     void Visit( SmBinHorNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmBinHorNode should have type NBINHOR",
-                                     NBINHOR, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmBinHorNode should have type SmNodeType::BinHor",
+                                     SmNodeType::BinHor, pNode->GetType());
         VisitChildren( pNode );
     }
 
     void Visit( SmBinVerNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmBinVerNode should have type NBINVER",
-                                     NBINVER, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmBinVerNode should have type SmNodeType::BinVer",
+                                     SmNodeType::BinVer, pNode->GetType());
         VisitChildren( pNode );
     }
 
     void Visit( SmBinDiagonalNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmBinDiagonalNode should have type NBINDIAGONAL",
-                                     NBINDIAGONAL, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmBinDiagonalNode should have type SmNodeType::BinDiagonal",
+                                     SmNodeType::BinDiagonal, pNode->GetType());
         VisitChildren( pNode );
     }
 
     void Visit( SmSubSupNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmSubSupNode should have type NSUBSUP",
-                                     NSUBSUP, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmSubSupNode should have type SmNodeType::SubSup",
+                                     SmNodeType::SubSup, pNode->GetType());
         VisitChildren( pNode );
     }
 
     void Visit( SmMatrixNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmMatrixNode should have type NMATRIX",
-                                     NMATRIX, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmMatrixNode should have type SmNodeType::Matrix",
+                                     SmNodeType::Matrix, pNode->GetType());
         CPPUNIT_ASSERT_EQUAL_MESSAGE("SmMatrixNode's token should be of type TMATRIX",
                                      TMATRIX, pNode->GetToken().eType);
         VisitChildren( pNode );
     }
 
     void Visit( SmPlaceNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmPlaceNode should have type NPLACE",
-                                     NPLACE, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmPlaceNode should have type SmNodeType::Place",
+                                     SmNodeType::Place, pNode->GetType());
     }
 
     void Visit( SmTextNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmTextNode should have type NTEXT",
-                                     NTEXT, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmTextNode should have type SmNodeType::Text",
+                                     SmNodeType::Text, pNode->GetType());
     }
 
     void Visit( SmSpecialNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmSpecialNode should have type NSPECIAL",
-                                     NSPECIAL, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmSpecialNode should have type SmNodeType::Special",
+                                     SmNodeType::Special, pNode->GetType());
     }
 
     void Visit( SmGlyphSpecialNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmGlyphSpecialNode should have type NGLYPH_SPECIAL",
-                                     NGLYPH_SPECIAL, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmGlyphSpecialNode should have type SmNodeType::GlyphSpecial",
+                                     SmNodeType::GlyphSpecial, pNode->GetType());
     }
 
     void Visit( SmMathSymbolNode* pNode ) override {
-        CPPUNIT_ASSERT_MESSAGE("SmMathSymbolNode should have type NMATH or NMATHIDENT",
-                               pNode->GetType() == NMATH || pNode->GetType() == NMATHIDENT);
+        CPPUNIT_ASSERT_MESSAGE("SmMathSymbolNode should have type SmNodeType::Math or SmNodeType::MathIdent",
+                               pNode->GetType() == SmNodeType::Math || pNode->GetType() == SmNodeType::MathIdent);
     }
 
     void Visit( SmBlankNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmBlankNode should have type NBLANK",
-                                     NBLANK, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmBlankNode should have type SmNodeType::Blank",
+                                     SmNodeType::Blank, pNode->GetType());
     }
 
     void Visit( SmErrorNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmErrorNode should have type NERROR",
-                                     NERROR, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmErrorNode should have type SmNodeType::Error",
+                                     SmNodeType::Error, pNode->GetType());
     }
 
     void Visit( SmLineNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmLineNode should have type NLINE",
-                                     NLINE, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmLineNode should have type SmNodeType::Line",
+                                     SmNodeType::Line, pNode->GetType());
         VisitChildren( pNode );
     }
 
     void Visit( SmExpressionNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmExpressionNode should have type NEXPRESSION",
-                                     NEXPRESSION, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmExpressionNode should have type SmNodeType::Expression",
+                                     SmNodeType::Expression, pNode->GetType());
         VisitChildren( pNode );
     }
 
     void Visit( SmPolyLineNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmPolyLineNode should have type NPOLYLINE",
-                                     NPOLYLINE, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmPolyLineNode should have type SmNodeType::PolyLine",
+                                     SmNodeType::PolyLine, pNode->GetType());
     }
 
     void Visit( SmRootNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmRootNode should have type NROOT",
-                                     NROOT, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmRootNode should have type SmNodeType::Root",
+                                     SmNodeType::Root, pNode->GetType());
         VisitChildren( pNode );
     }
 
     void Visit( SmRootSymbolNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmRootSymbolNode should have type NROOTSYMBOL",
-                                     NROOTSYMBOL, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmRootSymbolNode should have type SmNodeType::RootSymbol",
+                                     SmNodeType::RootSymbol, pNode->GetType());
     }
 
     void Visit( SmRectangleNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmRectangleNode should have type NRECTANGLE",
-                                     NRECTANGLE, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmRectangleNode should have type SmNodeType::Rectangle",
+                                     SmNodeType::Rectangle, pNode->GetType());
     }
 
     void Visit( SmVerticalBraceNode* pNode ) override {
-        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmVerticalBraceNode should have type NVERTICAL_BRACE",
-                                     NVERTICAL_BRACE, pNode->GetType());
+        CPPUNIT_ASSERT_EQUAL_MESSAGE("SmVerticalBraceNode should have type SmNodeType::VerticalBrace",
+                                     SmNodeType::VerticalBrace, pNode->GetType());
         VisitChildren( pNode );
     }
 
diff --git a/starmath/qa/cppunit/test_node.cxx b/starmath/qa/cppunit/test_node.cxx
index e36b8100f682..017089acc628 100644
--- a/starmath/qa/cppunit/test_node.cxx
+++ b/starmath/qa/cppunit/test_node.cxx
@@ -92,11 +92,11 @@ void NodeTest::testTdf52225()
         CPPUNIT_ASSERT_EQUAL(sal_uInt16(1), pTree->GetNumSubNodes());   \
         const SmNode *pLine = pTree->GetSubNode(0);                     \
         CPPUNIT_ASSERT(pLine);                                          \
-        CPPUNIT_ASSERT_EQUAL(NLINE, pLine->GetType());                  \
+        CPPUNIT_ASSERT_EQUAL(SmNodeType::Line, pLine->GetType());       \
         CPPUNIT_ASSERT_EQUAL(sal_uInt16(1), pLine->GetNumSubNodes());   \
         const SmNode *pNode = pLine->GetSubNode(0);                     \
         CPPUNIT_ASSERT(pNode);                                          \
-        CPPUNIT_ASSERT_EQUAL(NSPECIAL, pNode->GetType());               \
+        CPPUNIT_ASSERT_EQUAL(SmNodeType::Special, pNode->GetType());    \
         const SmSpecialNode *pSn = static_cast<const SmSpecialNode *>(pNode); \
         CPPUNIT_ASSERT_EQUAL(sal_Int32(1), pSn->GetText().getLength()); \
         CPPUNIT_ASSERT_EQUAL(sal_Unicode(code), pSn->GetText()[0]);     \
diff --git a/starmath/qa/cppunit/test_parse.cxx b/starmath/qa/cppunit/test_parse.cxx
index 12d21c240e0f..cd014ab3ad72 100644
--- a/starmath/qa/cppunit/test_parse.cxx
+++ b/starmath/qa/cppunit/test_parse.cxx
@@ -69,15 +69,15 @@ void ParseTest::testMinus()
     CPPUNIT_ASSERT_EQUAL(sal_uInt16(1), pNode->GetNumSubNodes());
     const SmNode *pNode0 = pNode->GetSubNode(0);
     CPPUNIT_ASSERT(pNode0);
-    CPPUNIT_ASSERT_EQUAL(NLINE, pNode0->GetType());
+    CPPUNIT_ASSERT_EQUAL(SmNodeType::Line, pNode0->GetType());
     CPPUNIT_ASSERT_EQUAL(sal_uInt16(1), pNode0->GetNumSubNodes());
     const SmNode *pNode00 = pNode0->GetSubNode(0);
     CPPUNIT_ASSERT(pNode00);
-    CPPUNIT_ASSERT_EQUAL(NUNHOR, pNode00->GetType());
+    CPPUNIT_ASSERT_EQUAL(SmNodeType::UnHor, pNode00->GetType());
     CPPUNIT_ASSERT_EQUAL(sal_uInt16(2), pNode00->GetNumSubNodes());
     const SmNode *pNode000 = pNode00->GetSubNode(0);
     CPPUNIT_ASSERT(pNode000);
-    CPPUNIT_ASSERT_EQUAL(NMATH, pNode000->GetType());
+    CPPUNIT_ASSERT_EQUAL(SmNodeType::Math, pNode000->GetType());
     // GetText() vs GetToken().aText
     CPPUNIT_ASSERT_EQUAL(OUString(MS_MINUS),
                          static_cast<const SmMathSymbolNode *>(pNode000)->GetText());
@@ -85,7 +85,7 @@ void ParseTest::testMinus()
                          static_cast<const SmMathSymbolNode *>(pNode000)->GetToken().aText);
     const SmNode *pNode001 = pNode00->GetSubNode(1);
     CPPUNIT_ASSERT(pNode001);
-    CPPUNIT_ASSERT_EQUAL(NTEXT, pNode001->GetType());
+    CPPUNIT_ASSERT_EQUAL(SmNodeType::Text, pNode001->GetType());
     // GetText() vs GetToken().aText
     CPPUNIT_ASSERT(static_cast<const SmTextNode *>(pNode001)->GetText().isEmpty());
     CPPUNIT_ASSERT_EQUAL(OUString("1.2"),
@@ -102,21 +102,21 @@ void ParseTest::testNospace()
     CPPUNIT_ASSERT_EQUAL(sal_uInt16(1), pNode->GetNumSubNodes());
     const SmNode *pNode0 = pNode->GetSubNode(0);
     CPPUNIT_ASSERT(pNode0);
-    CPPUNIT_ASSERT_EQUAL(NLINE, pNode0->GetType());
+    CPPUNIT_ASSERT_EQUAL(SmNodeType::Line, pNode0->GetType());
     CPPUNIT_ASSERT_EQUAL(sal_uInt16(1), pNode0->GetNumSubNodes());
     const SmNode *pNode00 = pNode0->GetSubNode(0);
     CPPUNIT_ASSERT(pNode00);
-    CPPUNIT_ASSERT_EQUAL(NEXPRESSION, pNode00->GetType());
+    CPPUNIT_ASSERT_EQUAL(SmNodeType::Expression, pNode00->GetType());
     CPPUNIT_ASSERT(!static_cast<const SmExpressionNode *>(pNode00)->IsUseExtraSpaces());
     CPPUNIT_ASSERT_EQUAL(sal_uInt16(2), pNode00->GetNumSubNodes());
     const SmNode *pNode000 = pNode00->GetSubNode(0);
     CPPUNIT_ASSERT(pNode000);
-    CPPUNIT_ASSERT_EQUAL(NFONT, pNode000->GetType());
+    CPPUNIT_ASSERT_EQUAL(SmNodeType::Font, pNode000->GetType());
     CPPUNIT_ASSERT_EQUAL(OUString("nitalic"),
                          static_cast<const SmFontNode *>(pNode000)->GetToken().aText);
     const SmNode *pNode001 = pNode00->GetSubNode(1);
     CPPUNIT_ASSERT(pNode001);
-    CPPUNIT_ASSERT_EQUAL(NEXPRESSION, pNode001->GetType());
+    CPPUNIT_ASSERT_EQUAL(SmNodeType::Expression, pNode001->GetType());
     CPPUNIT_ASSERT(static_cast<const SmExpressionNode *>(pNode001)->IsUseExtraSpaces());
     CPPUNIT_ASSERT_EQUAL(sal_uInt16(2), pNode00->GetNumSubNodes());
 }