comphelper, drawinglayer, framework, starmath: clang-format these files

I added these files more or less recently and they have long lines. Use
clang-format to break at a sane column limit.

Change-Id: Id608fffbbc0673c9bc350dd696cb0a31906840d3
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/94423
Reviewed-by: Miklos Vajna <vmiklos@collabora.com>
Tested-by: Jenkins

2 files changed, 104 insertions, 105 deletions

diff --git a/starmath/source/wordexportbase.cxx b/starmath/source/wordexportbase.cxx
index 1f802e2e6e92..7f4699dfb952 100644
--- a/starmath/source/wordexportbase.cxx
+++ b/starmath/source/wordexportbase.cxx
@@ -21,84 +21,85 @@ SmWordExportBase::~SmWordExportBase() = default;
 
 void SmWordExportBase::HandleNode(const SmNode* pNode, int nLevel)
 {
-    SAL_INFO("starmath.wordbase", "Node: " << nLevel << " " << int(pNode->GetType()) << " " << pNode->GetNumSubNodes());
+    SAL_INFO("starmath.wordbase",
+             "Node: " << nLevel << " " << int(pNode->GetType()) << " " << pNode->GetNumSubNodes());
     switch (pNode->GetType())
     {
-    case SmNodeType::Attribut:
-        HandleAttribute(static_cast< const SmAttributNode* >(pNode), nLevel);
-        break;
-    case SmNodeType::Text:
-        HandleText(pNode,nLevel);
-        break;
-    case SmNodeType::VerticalBrace:
-        HandleVerticalBrace(static_cast< const SmVerticalBraceNode* >(pNode), nLevel);
-        break;
-    case SmNodeType::Brace:
-        HandleBrace(static_cast< const SmBraceNode* >(pNode), nLevel);
-        break;
-    case SmNodeType::Oper:
-        HandleOperator(static_cast< const SmOperNode* >(pNode), nLevel);
-        break;
-    case SmNodeType::UnHor:
-        HandleUnaryOperation(static_cast< const SmUnHorNode* >(pNode), nLevel);
-        break;
-    case SmNodeType::BinHor:
-        HandleBinaryOperation(static_cast< const SmBinHorNode* >(pNode), nLevel);
-        break;
-    case SmNodeType::BinVer:
-        HandleFractions(pNode,nLevel,nullptr);
-        break;
-    case SmNodeType::Root:
-        HandleRoot(static_cast< const SmRootNode* >(pNode), nLevel);
-        break;
-    case SmNodeType::Special:
-    {
-        auto pText= static_cast<const SmTextNode*>(pNode);
-        //if the token str and the result text are the same then this
-        //is to be seen as text, else assume it's a mathchar
-        if (pText->GetText() == pText->GetToken().aText)
-            HandleText(pText,nLevel);
-        else
-            HandleMath(pText,nLevel);
-        break;
-    }
-    case SmNodeType::Math:
-    case SmNodeType::MathIdent:
-        HandleMath(pNode,nLevel);
-        break;
-    case SmNodeType::SubSup:
-        HandleSubSupScript(static_cast< const SmSubSupNode* >(pNode), nLevel);
-        break;
-    case SmNodeType::Expression:
-        HandleAllSubNodes(pNode, nLevel);
-        break;
-    case SmNodeType::Table:
-        //Root Node, PILE equivalent, i.e. vertical stack
-        HandleTable(pNode,nLevel);
-        break;
-    case SmNodeType::Matrix:
-        HandleMatrix(static_cast< const SmMatrixNode* >(pNode), nLevel);
+        case SmNodeType::Attribut:
+            HandleAttribute(static_cast<const SmAttributNode*>(pNode), nLevel);
+            break;
+        case SmNodeType::Text:
+            HandleText(pNode, nLevel);
+            break;
+        case SmNodeType::VerticalBrace:
+            HandleVerticalBrace(static_cast<const SmVerticalBraceNode*>(pNode), nLevel);
+            break;
+        case SmNodeType::Brace:
+            HandleBrace(static_cast<const SmBraceNode*>(pNode), nLevel);
+            break;
+        case SmNodeType::Oper:
+            HandleOperator(static_cast<const SmOperNode*>(pNode), nLevel);
+            break;
+        case SmNodeType::UnHor:
+            HandleUnaryOperation(static_cast<const SmUnHorNode*>(pNode), nLevel);
+            break;
+        case SmNodeType::BinHor:
+            HandleBinaryOperation(static_cast<const SmBinHorNode*>(pNode), nLevel);
+            break;
+        case SmNodeType::BinVer:
+            HandleFractions(pNode, nLevel, nullptr);
+            break;
+        case SmNodeType::Root:
+            HandleRoot(static_cast<const SmRootNode*>(pNode), nLevel);
+            break;
+        case SmNodeType::Special:
+        {
+            auto pText = static_cast<const SmTextNode*>(pNode);
+            //if the token str and the result text are the same then this
+            //is to be seen as text, else assume it's a mathchar
+            if (pText->GetText() == pText->GetToken().aText)
+                HandleText(pText, nLevel);
+            else
+                HandleMath(pText, nLevel);
+            break;
+        }
+        case SmNodeType::Math:
+        case SmNodeType::MathIdent:
+            HandleMath(pNode, nLevel);
+            break;
+        case SmNodeType::SubSup:
+            HandleSubSupScript(static_cast<const SmSubSupNode*>(pNode), nLevel);
+            break;
+        case SmNodeType::Expression:
+            HandleAllSubNodes(pNode, nLevel);
+            break;
+        case SmNodeType::Table:
+            //Root Node, PILE equivalent, i.e. vertical stack
+            HandleTable(pNode, nLevel);
+            break;
+        case SmNodeType::Matrix:
+            HandleMatrix(static_cast<const SmMatrixNode*>(pNode), nLevel);
+            break;
+        case SmNodeType::Line:
+        {
+            // TODO
+            HandleAllSubNodes(pNode, nLevel);
+        }
         break;
-    case SmNodeType::Line:
-    {
-// TODO
-        HandleAllSubNodes(pNode, nLevel);
-    }
-    break;
 #if 0
     case SmNodeType::Align:
         HandleMAlign(pNode,nLevel);
         break;
 #endif
-    case SmNodeType::Place:
-        // explicitly do nothing, MSOffice treats that as a placeholder if item is missing
-        break;
-    case SmNodeType::Blank:
-        HandleBlank();
-        break;
-    default:
-        HandleAllSubNodes(pNode, nLevel);
-        break;
+        case SmNodeType::Place:
+            // explicitly do nothing, MSOffice treats that as a placeholder if item is missing
+            break;
+        case SmNodeType::Blank:
+            HandleBlank();
+            break;
+        default:
+            HandleAllSubNodes(pNode, nLevel);
+            break;
     }
 }
 
@@ -120,11 +121,9 @@ void SmWordExportBase::HandleTable(const SmNode* pNode, int nLevel)
 void SmWordExportBase::HandleAllSubNodes(const SmNode* pNode, int nLevel)
 {
     int size = pNode->GetNumSubNodes();
-    for (int i = 0;
-            i < size;
-            ++i)
+    for (int i = 0; i < size; ++i)
     {
-// TODO remove when all types of nodes are handled properly
+        // TODO remove when all types of nodes are handled properly
         if (pNode->GetSubNode(i) == nullptr)
         {
             SAL_WARN("starmath.wordbase", "Subnode is NULL, parent node not handled properly");
@@ -148,11 +147,11 @@ void SmWordExportBase::HandleBinaryOperation(const SmBinHorNode* pNode, int nLev
     // update HandleMath() when adding new items
     switch (pNode->Symbol()->GetToken().eType)
     {
-    case TDIVIDEBY:
-        return HandleFractions(pNode, nLevel, "lin");
-    default:
-        HandleAllSubNodes(pNode, nLevel);
-        break;
+        case TDIVIDEBY:
+            return HandleFractions(pNode, nLevel, "lin");
+        default:
+            HandleAllSubNodes(pNode, nLevel);
+            break;
     }
 }
 
@@ -161,13 +160,13 @@ void SmWordExportBase::HandleMath(const SmNode* pNode, int nLevel)
     SAL_INFO("starmath.wordbase", "Math: " << int(pNode->GetToken().eType));
     switch (pNode->GetToken().eType)
     {
-    case TDIVIDEBY:
-    case TACUTE:
-        OSL_ASSERT(false);
-        [[fallthrough]]; // the above are handled elsewhere, e.g. when handling BINHOR
-    default:
-        HandleText(pNode, nLevel);
-        break;
+        case TDIVIDEBY:
+        case TACUTE:
+            OSL_ASSERT(false);
+            [[fallthrough]]; // the above are handled elsewhere, e.g. when handling BINHOR
+        default:
+            HandleText(pNode, nLevel);
+            break;
     }
 }
 
diff --git a/starmath/source/wordexportbase.hxx b/starmath/source/wordexportbase.hxx
index b5b0d6853cbf..4f191df2aa4e 100644
--- a/starmath/source/wordexportbase.hxx
+++ b/starmath/source/wordexportbase.hxx
@@ -27,31 +27,31 @@ class SmVerticalBraceNode;
 class SmWordExportBase
 {
 public:
-    explicit SmWordExportBase( const SmNode* pIn );
+    explicit SmWordExportBase(const SmNode* pIn);
     virtual ~SmWordExportBase();
+
 protected:
-    void HandleNode( const SmNode* pNode, int nLevel );
-    void HandleAllSubNodes( const SmNode* pNode, int nLevel );
-    void HandleTable( const SmNode* pNode, int nLevel );
-    virtual void HandleVerticalStack( const SmNode* pNode, int nLevel ) = 0;
-    virtual void HandleText( const SmNode* pNode, int nLevel ) = 0;
-    void HandleMath( const SmNode* pNode, int nLevel );
-    virtual void HandleFractions( const SmNode* pNode, int nLevel, const char* type ) = 0;
-    void HandleUnaryOperation( const SmUnHorNode* pNode, int nLevel );
-    void HandleBinaryOperation( const SmBinHorNode* pNode, int nLevel );
-    virtual void HandleRoot( const SmRootNode* pNode, int nLevel ) = 0;
-    virtual void HandleAttribute( const SmAttributNode* pNode, int nLevel ) = 0;
-    virtual void HandleOperator( const SmOperNode* pNode, int nLevel ) = 0;
-    void HandleSubSupScript( const SmSubSupNode* pNode, int nLevel );
-    virtual void HandleSubSupScriptInternal( const SmSubSupNode* pNode, int nLevel, int flags ) = 0;
-    virtual void HandleMatrix( const SmMatrixNode* pNode, int nLevel ) = 0;
-    virtual void HandleBrace( const SmBraceNode* pNode, int nLevel ) = 0;
-    virtual void HandleVerticalBrace( const SmVerticalBraceNode* pNode, int nLevel ) = 0;
+    void HandleNode(const SmNode* pNode, int nLevel);
+    void HandleAllSubNodes(const SmNode* pNode, int nLevel);
+    void HandleTable(const SmNode* pNode, int nLevel);
+    virtual void HandleVerticalStack(const SmNode* pNode, int nLevel) = 0;
+    virtual void HandleText(const SmNode* pNode, int nLevel) = 0;
+    void HandleMath(const SmNode* pNode, int nLevel);
+    virtual void HandleFractions(const SmNode* pNode, int nLevel, const char* type) = 0;
+    void HandleUnaryOperation(const SmUnHorNode* pNode, int nLevel);
+    void HandleBinaryOperation(const SmBinHorNode* pNode, int nLevel);
+    virtual void HandleRoot(const SmRootNode* pNode, int nLevel) = 0;
+    virtual void HandleAttribute(const SmAttributNode* pNode, int nLevel) = 0;
+    virtual void HandleOperator(const SmOperNode* pNode, int nLevel) = 0;
+    void HandleSubSupScript(const SmSubSupNode* pNode, int nLevel);
+    virtual void HandleSubSupScriptInternal(const SmSubSupNode* pNode, int nLevel, int flags) = 0;
+    virtual void HandleMatrix(const SmMatrixNode* pNode, int nLevel) = 0;
+    virtual void HandleBrace(const SmBraceNode* pNode, int nLevel) = 0;
+    virtual void HandleVerticalBrace(const SmVerticalBraceNode* pNode, int nLevel) = 0;
     virtual void HandleBlank() = 0;
     const SmNode* const m_pTree;
 };
 
-
 #endif
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */