starmath/source/wordexportbase.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   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 "wordexportbase.hxx"
  11 #include <sal/log.hxx>
  12 #include <osl/diagnose.h>
  13
  14 SmWordExportBase::SmWordExportBase(const SmNode* pIn)
  15     : m_pTree(pIn)
  16 {
  17 }
  18
  19 SmWordExportBase::~SmWordExportBase() = default;
  20
  21 void SmWordExportBase::HandleNode(const SmNode* pNode, int nLevel)
  22 {
  23     SAL_INFO("starmath.wordbase",
  24              "Node: " << nLevel << " " << int(pNode->GetType()) << " " << pNode->GetNumSubNodes());
  25     switch (pNode->GetType())
  26     {
  27         case SmNodeType::Attribute:
  28             HandleAttribute(static_cast<const SmAttributeNode*>(pNode), nLevel);
  29             break;
  30         case SmNodeType::Text:
  31             HandleText(pNode, nLevel);
  32             break;
  33         case SmNodeType::VerticalBrace:
  34             HandleVerticalBrace(static_cast<const SmVerticalBraceNode*>(pNode), nLevel);
  35             break;
  36         case SmNodeType::Brace:
  37             HandleBrace(static_cast<const SmBraceNode*>(pNode), nLevel);
  38             break;
  39         case SmNodeType::Oper:
  40             HandleOperator(static_cast<const SmOperNode*>(pNode), nLevel);
  41             break;
  42         case SmNodeType::UnHor:
  43             HandleUnaryOperation(static_cast<const SmUnHorNode*>(pNode), nLevel);
  44             break;
  45         case SmNodeType::BinHor:
  46             HandleBinaryOperation(static_cast<const SmBinHorNode*>(pNode), nLevel);
  47             break;
  48         case SmNodeType::BinVer:
  49             HandleFractions(pNode, nLevel, nullptr);
  50             break;
  51         case SmNodeType::Root:
  52             HandleRoot(static_cast<const SmRootNode*>(pNode), nLevel);
  53             break;
  54         case SmNodeType::Special:
  55         {
  56             auto pText = static_cast<const SmTextNode*>(pNode);
  57             //if the token str and the result text are the same then this
  58             //is to be seen as text, else assume it's a mathchar
  59             if (pText->GetText() == pText->GetToken().aText)
  60                 HandleText(pText, nLevel);
  61             else
  62                 HandleMath(pText, nLevel);
  63             break;
  64         }
  65         case SmNodeType::Math:
  66         case SmNodeType::MathIdent:
  67             HandleMath(pNode, nLevel);
  68             break;
  69         case SmNodeType::SubSup:
  70             HandleSubSupScript(static_cast<const SmSubSupNode*>(pNode), nLevel);
  71             break;
  72         case SmNodeType::Expression:
  73             HandleAllSubNodes(pNode, nLevel);
  74             break;
  75         case SmNodeType::Table:
  76             //Root Node, PILE equivalent, i.e. vertical stack
  77             HandleTable(pNode, nLevel);
  78             break;
  79         case SmNodeType::Matrix:
  80             HandleMatrix(static_cast<const SmMatrixNode*>(pNode), nLevel);
  81             break;
  82         case SmNodeType::Line:
  83         {
  84             // TODO
  85             HandleAllSubNodes(pNode, nLevel);
  86         }
  87         break;
  88 #if 0
  89     case SmNodeType::Align:
  90         HandleMAlign(pNode,nLevel);
  91         break;
  92 #endif
  93         case SmNodeType::Place:
  94             // explicitly do nothing, MSOffice treats that as a placeholder if item is missing
  95             break;
  96         case SmNodeType::Blank:
  97             HandleBlank();
  98             break;
  99         default:
 100             HandleAllSubNodes(pNode, nLevel);
 101             break;
 102     }
 103 }
 104
 105 //Root Node, PILE equivalent, i.e. vertical stack
 106 void SmWordExportBase::HandleTable(const SmNode* pNode, int nLevel)
 107 {
 108     //The root of the starmath is a table, if
 109     //we convert this them each iteration of
 110     //conversion from starmath to Word will
 111     //add an extra unnecessary level to the
 112     //Word output stack which would grow
 113     //without bound in a multi step conversion
 114     if (nLevel || pNode->GetNumSubNodes() > 1)
 115         HandleVerticalStack(pNode, nLevel);
 116     else
 117         HandleAllSubNodes(pNode, nLevel);
 118 }
 119
 120 void SmWordExportBase::HandleAllSubNodes(const SmNode* pNode, int nLevel)
 121 {
 122     int size = pNode->GetNumSubNodes();
 123     for (int i = 0; i < size; ++i)
 124     {
 125         // TODO remove when all types of nodes are handled properly
 126         if (pNode->GetSubNode(i) == nullptr)
 127         {
 128             SAL_WARN("starmath.wordbase", "Subnode is NULL, parent node not handled properly");
 129             continue;
 130         }
 131         HandleNode(pNode->GetSubNode(i), nLevel + 1);
 132     }
 133 }
 134
 135 void SmWordExportBase::HandleUnaryOperation(const SmUnHorNode* pNode, int nLevel)
 136 {
 137     // update HandleMath() when adding new items
 138     SAL_INFO("starmath.wordbase", "Unary: " << int(pNode->GetToken().eType));
 139
 140     HandleAllSubNodes(pNode, nLevel);
 141 }
 142
 143 void SmWordExportBase::HandleBinaryOperation(const SmBinHorNode* pNode, int nLevel)
 144 {
 145     SAL_INFO("starmath.wordbase", "Binary: " << int(pNode->Symbol()->GetToken().eType));
 146     // update HandleMath() when adding new items
 147     switch (pNode->Symbol()->GetToken().eType)
 148     {
 149         case TDIVIDEBY:
 150             return HandleFractions(pNode, nLevel, "lin");
 151         default:
 152             HandleAllSubNodes(pNode, nLevel);
 153             break;
 154     }
 155 }
 156
 157 void SmWordExportBase::HandleMath(const SmNode* pNode, int nLevel)
 158 {
 159     SAL_INFO("starmath.wordbase", "Math: " << int(pNode->GetToken().eType));
 160     switch (pNode->GetToken().eType)
 161     {
 162         case TDIVIDEBY:
 163         case TACUTE:
 164             OSL_ASSERT(false);
 165             [[fallthrough]]; // the above are handled elsewhere, e.g. when handling BINHOR
 166         default:
 167             HandleText(pNode, nLevel);
 168             break;
 169     }
 170 }
 171
 172 void SmWordExportBase::HandleSubSupScript(const SmSubSupNode* pNode, int nLevel)
 173 {
 174     // set flags to a bitfield of which sub/sup items exists
 175     int flags = (pNode->GetSubSup(CSUB) != nullptr ? (1 << CSUB) : 0)
 176                 | (pNode->GetSubSup(CSUP) != nullptr ? (1 << CSUP) : 0)
 177                 | (pNode->GetSubSup(RSUB) != nullptr ? (1 << RSUB) : 0)
 178                 | (pNode->GetSubSup(RSUP) != nullptr ? (1 << RSUP) : 0)
 179                 | (pNode->GetSubSup(LSUB) != nullptr ? (1 << LSUB) : 0)
 180                 | (pNode->GetSubSup(LSUP) != nullptr ? (1 << LSUP) : 0);
 181     HandleSubSupScriptInternal(pNode, nLevel, flags);
 182 }
 183
 184 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */