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 <node.hxx>
  12 #include <sal/log.hxx>
  13 #include <osl/diagnose.h>
  14
  15 SmWordExportBase::SmWordExportBase(const SmNode* pIn)
  16     : m_pTree(pIn)
  17 {
  18 }
  19
  20 SmWordExportBase::~SmWordExportBase() = default;
  21
  22 void SmWordExportBase::HandleNode(const SmNode* pNode, int nLevel)
  23 {
  24     SAL_INFO("starmath.wordbase", "Node: " << nLevel << " " << int(pNode->GetType()) << " " << pNode->GetNumSubNodes());
  25     switch (pNode->GetType())
  26     {
  27     case SmNodeType::Attribut:
  28         HandleAttribute(static_cast< const SmAttributNode* >(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;
 124             i < size;
 125             ++i)
 126     {
 127 // TODO remove when all types of nodes are handled properly
 128         if (pNode->GetSubNode(i) == nullptr)
 129         {
 130             SAL_WARN("starmath.wordbase", "Subnode is NULL, parent node not handled properly");
 131             continue;
 132         }
 133         HandleNode(pNode->GetSubNode(i), nLevel + 1);
 134     }
 135 }
 136
 137 void SmWordExportBase::HandleUnaryOperation(const SmUnHorNode* pNode, int nLevel)
 138 {
 139     // update HandleMath() when adding new items
 140     SAL_INFO("starmath.wordbase", "Unary: " << int(pNode->GetToken().eType));
 141
 142     HandleAllSubNodes(pNode, nLevel);
 143 }
 144
 145 void SmWordExportBase::HandleBinaryOperation(const SmBinHorNode* pNode, int nLevel)
 146 {
 147     SAL_INFO("starmath.wordbase", "Binary: " << int(pNode->Symbol()->GetToken().eType));
 148     // update HandleMath() when adding new items
 149     switch (pNode->Symbol()->GetToken().eType)
 150     {
 151     case TDIVIDEBY:
 152         return HandleFractions(pNode, nLevel, "lin");
 153     default:
 154         HandleAllSubNodes(pNode, nLevel);
 155         break;
 156     }
 157 }
 158
 159 void SmWordExportBase::HandleMath(const SmNode* pNode, int nLevel)
 160 {
 161     SAL_INFO("starmath.wordbase", "Math: " << int(pNode->GetToken().eType));
 162     switch (pNode->GetToken().eType)
 163     {
 164     case TDIVIDEBY:
 165     case TACUTE:
 166         OSL_ASSERT(false);
 167         [[fallthrough]]; // the above are handled elsewhere, e.g. when handling BINHOR
 168     default:
 169         HandleText(pNode, nLevel);
 170         break;
 171     }
 172 }
 173
 174 void SmWordExportBase::HandleSubSupScript(const SmSubSupNode* pNode, int nLevel)
 175 {
 176     // set flags to a bitfield of which sub/sup items exists
 177     int flags = (pNode->GetSubSup(CSUB) != nullptr ? (1 << CSUB) : 0)
 178                 | (pNode->GetSubSup(CSUP) != nullptr ? (1 << CSUP) : 0)
 179                 | (pNode->GetSubSup(RSUB) != nullptr ? (1 << RSUB) : 0)
 180                 | (pNode->GetSubSup(RSUP) != nullptr ? (1 << RSUP) : 0)
 181                 | (pNode->GetSubSup(LSUB) != nullptr ? (1 << LSUB) : 0)
 182                 | (pNode->GetSubSup(LSUP) != nullptr ? (1 << LSUP) : 0);
 183     HandleSubSupScriptInternal(pNode, nLevel, flags);
 184 }
 185
 186 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */