24#include <com/sun/star/xml/sax/InputSource.hpp>
25#include <com/sun/star/xml/sax/FastParser.hpp>
26#include <com/sun/star/xml/sax/Parser.hpp>
27#include <com/sun/star/xml/sax/SAXParseException.hpp>
28#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
29#include <com/sun/star/packages/WrongPasswordException.hpp>
30#include <com/sun/star/packages/zip/ZipIOException.hpp>
31#include <com/sun/star/beans/PropertyAttribute.hpp>
32#include <com/sun/star/embed/ElementModes.hpp>
33#include <com/sun/star/uno/Any.h>
34#include <com/sun/star/task/XStatusIndicator.hpp>
41#include <rtl/character.hxx>
45#include <sfx2/sfxsids.hrc>
47#include <osl/diagnose.h>
60#include <svx/strings.hrc>
67#include <document.hxx>
69#include <unomodel.hxx>
86std::unique_ptr<SmNode> popOrZero(
SmNodeStack& rStack)
90 auto pTmp = std::move(rStack.front());
102 OSL_ENSURE(
m_xModel.is(),
"XMLReader::Read: got no model");
105 uno::Reference<task::XStatusIndicator> xStatusIndicator;
107 bool bEmbedded =
false;
113 OSL_ENSURE(pDocShell->
GetMedium() == &rMedium,
"different SfxMedium found");
117 pItem->
GetValue() >>= xStatusIndicator;
119 if (SfxObjectCreateMode::EMBEDDED == pDocShell->
GetCreateMode())
125 beans::PropertyAttribute::MAYBEVOID, 0 },
127 beans::PropertyAttribute::MAYBEVOID, 0 },
129 beans::PropertyAttribute::MAYBEVOID, 0 },
131 beans::PropertyAttribute::MAYBEVOID, 0 } };
132 uno::Reference<beans::XPropertySet> xInfoSet(
139 SAL_INFO_IF(baseURI.isEmpty(),
"starmath",
"SmXMLImportWrapper: no base URL");
140 xInfoSet->setPropertyValue(
"BaseURI",
Any(baseURI));
142 sal_Int32 nSteps = 3;
146 sal_Int32 nProgressRange(nSteps);
147 if (xStatusIndicator.is())
149 xStatusIndicator->start(
SvxResId(RID_SVXSTR_DOC_LOAD), nProgressRange);
153 if (xStatusIndicator.is())
154 xStatusIndicator->setValue(nSteps++);
161 OUString
aName(
"dummyObjName");
164 if (pDocHierarchItem)
167 if (!
aName.isEmpty())
169 xInfoSet->setPropertyValue(
"StreamRelPath",
Any(
aName));
174 if (xStatusIndicator.is())
175 xStatusIndicator->setValue(nSteps++);
179 (bOASIS ?
"com.sun.star.comp.Math.XMLOasisMetaImporter"
180 :
"com.sun.star.comp.Math.XMLMetaImporter"),
185 if (xStatusIndicator.is())
186 xStatusIndicator->setValue(nSteps++);
190 (bOASIS ?
"com.sun.star.comp.Math.XMLOasisSettingsImporter"
191 :
"com.sun.star.comp.Math.XMLSettingsImporter"),
196 if (xStatusIndicator.is())
197 xStatusIndicator->setValue(nSteps++);
211 Reference<io::XInputStream> xInputStream
214 if (xStatusIndicator.is())
215 xStatusIndicator->setValue(nSteps++);
218 "com.sun.star.comp.Math.XMLImporter",
false,
222 if (xStatusIndicator.is())
223 xStatusIndicator->end();
229 const Reference<XComponent>& xModelComponent,
230 Reference<uno::XComponentContext>
const& rxContext,
231 Reference<beans::XPropertySet>
const& rPropSet,
232 const char* pFilterName,
bool bEncrypted,
233 bool bUseHTMLMLEntities)
236 OSL_ENSURE(xInputStream.is(),
"input stream missing");
237 OSL_ENSURE(xModelComponent.is(),
"document missing");
238 OSL_ENSURE(rxContext.is(),
"factory missing");
239 OSL_ENSURE(
nullptr != pFilterName,
"I need a service name for the component!");
242 xml::sax::InputSource aParserInput;
243 aParserInput.aInputStream = xInputStream;
245 Sequence<Any> aArgs{
Any(rPropSet) };
248 Reference<XInterface> xFilter
249 = rxContext->getServiceManager()->createInstanceWithArgumentsAndContext(
250 OUString::createFromAscii(pFilterName), aArgs, rxContext);
251 SAL_WARN_IF(!xFilter,
"starmath",
"Can't instantiate filter component " << pFilterName);
256 Reference<XImporter> xImporter(xFilter, UNO_QUERY);
257 xImporter->setTargetDocument(xModelComponent);
262 Reference<css::xml::sax::XFastParser> xFastParser(xFilter, UNO_QUERY);
263 Reference<css::xml::sax::XFastDocumentHandler> xFastDocHandler(xFilter, UNO_QUERY);
266 if (bUseHTMLMLEntities)
268 xFastParser->parseStream(aParserInput);
270 else if (xFastDocHandler)
272 Reference<css::xml::sax::XFastParser> xParser
273 = css::xml::sax::FastParser::create(rxContext);
274 if (bUseHTMLMLEntities)
276 xParser->setFastDocumentHandler(xFastDocHandler);
277 xParser->parseStream(aParserInput);
281 Reference<css::xml::sax::XDocumentHandler> xDocHandler(xFilter, UNO_QUERY);
283 Reference<css::xml::sax::XParser> xParser = css::xml::sax::Parser::create(rxContext);
284 xParser->setDocumentHandler(xDocHandler);
285 xParser->parseStream(aParserInput);
288 auto pFilter =
dynamic_cast<SmXMLImport*
>(xFilter.get());
289 if (pFilter && pFilter->GetSuccess())
290 nError = ERRCODE_NONE;
292 catch (
const xml::sax::SAXParseException& r)
296 xml::sax::SAXException aSaxEx = *
static_cast<const xml::sax::SAXException*
>(&r);
297 bool bTryChild =
true;
301 xml::sax::SAXException aTmp;
302 if (aSaxEx.WrappedException >>= aTmp)
308 packages::zip::ZipIOException aBrokenPackage;
309 if (aSaxEx.WrappedException >>= aBrokenPackage)
315 catch (
const xml::sax::SAXException& r)
317 packages::zip::ZipIOException aBrokenPackage;
318 if (r.WrappedException >>= aBrokenPackage)
324 catch (
const packages::zip::ZipIOException&)
328 catch (
const io::IOException&)
331 catch (
const std::range_error&)
339 const Reference<XComponent>& xModelComponent,
340 const char* pStreamName,
341 Reference<uno::XComponentContext>
const& rxContext,
342 Reference<beans::XPropertySet>
const& rPropSet,
343 const char* pFilterName,
bool bUseHTMLMLEntities)
345 OSL_ENSURE(xStorage.is(),
"Need storage!");
346 OSL_ENSURE(
nullptr != pStreamName,
"Please, please, give me a name!");
349 OUString sStreamName = OUString::createFromAscii(pStreamName);
354 uno::Reference<io::XStream> xEventsStream
355 = xStorage->openStreamElement(sStreamName, embed::ElementModes::READ);
358 uno::Reference<beans::XPropertySet> xProps(xEventsStream, uno::UNO_QUERY);
359 Any aAny = xProps->getPropertyValue(
"Encrypted");
360 bool bEncrypted =
false;
367 rPropSet->setPropertyValue(
"StreamName",
Any(sStreamName));
370 Reference<io::XInputStream>
xStream = xEventsStream->getInputStream();
372 bEncrypted, bUseHTMLMLEntities);
374 catch (packages::WrongPasswordException&)
378 catch (packages::zip::ZipIOException&)
382 catch (uno::Exception&)
394 , mnSmSyntaxVersion(
SM_MOD()->GetConfig()->GetDefaultSmSyntaxVersion())
398extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
400 uno::Sequence<uno::Any>
const& )
402 return cppu::acquire(
403 new SmXMLImport(pCtx,
"com.sun.star.comp.Math.XMLImporter", SvXMLImportFlags::ALL));
406extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
408 uno::Sequence<uno::Any>
const& )
410 return cppu::acquire(
new SmXMLImport(pCtx,
"com.sun.star.comp.Math.XMLOasisMetaImporter",
411 SvXMLImportFlags::META));
414extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
416 uno::Sequence<uno::Any>
const& )
418 return cppu::acquire(
new SmXMLImport(pCtx,
"com.sun.star.comp.Math.XMLOasisSettingsImporter",
419 SvXMLImportFlags::SETTINGS));
425 std::unique_ptr<SmNode> pTree = popOrZero(
aNodeStack);
428 uno::Reference<frame::XModel>
xModel = GetModel();
434 auto pTreeTmp = pTree.get();
454 OSL_ENSURE(pModel,
"So there *was* a UNO problem after all");
459 SvXMLImport::endDocument();
470 GetSmImport().IncParseDepth();
473 virtual ~SmXMLImportContext()
override { GetSmImport().DecParseDepth(); }
477 virtual void TCharacters(
const OUString& );
478 virtual void SAL_CALL
characters(
const OUString& rChars)
override;
481 const css::uno::Reference<css::xml::sax::XFastAttributeList>& )
override
483 if (GetSmImport().TooDeep())
484 throw std::range_error(
"too deep");
489void SmXMLImportContext::TCharacters(
const OUString& ) {}
491void SmXMLImportContext::characters(
const OUString& rChars)
500 const OUString& rChars2 = rChars.trim();
501 if (!rChars2.isEmpty())
502 TCharacters(rChars2 );
507struct SmXMLContext_Helper
512 OUString sFontFamily;
515 SmXMLImportContext& rContext;
517 explicit SmXMLContext_Helper(SmXMLImportContext& rImport)
525 bool IsFontNodeNeeded()
const;
526 void RetrieveAttrs(
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList);
531bool SmXMLContext_Helper::IsFontNodeNeeded()
const
533 return nIsBold != -1 || nIsItalic != -1 || nFontSize != 0.0 || !sFontFamily.isEmpty()
537void SmXMLContext_Helper::RetrieveAttrs(
538 const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
540 bool bMvFound =
false;
544 switch (aIter.getToken() & TOKEN_MASK)
555 OUString sValue = aIter.toString();
557 rContext.GetSmImport().GetMM100UnitConverter().SetXMLMeasureUnit(
558 util::MeasureUnit::POINT);
559 if (-1 == sValue.indexOf(
GetXMLToken(XML_UNIT_PT)))
561 if (-1 == sValue.indexOf(
'%'))
565 rContext.GetSmImport().GetMM100UnitConverter().SetXMLMeasureUnit(
566 util::MeasureUnit::PERCENT);
572 sFontFamily = aIter.toString();
575 sColor = aIter.toString();
578 sColor = aIter.toString();
600void SmXMLContext_Helper::ApplyAttrs()
602 SmNodeStack& rNodeStack = rContext.GetSmImport().GetNodeStack();
604 if (!IsFontNodeNeeded())
617 std::unique_ptr<SmFontNode> pFontNode(
new SmFontNode(aToken));
618 pFontNode->SetSubNodes(
nullptr, popOrZero(rNodeStack));
619 rNodeStack.push_front(std::move(pFontNode));
627 std::unique_ptr<SmFontNode> pFontNode(
new SmFontNode(aToken));
628 pFontNode->SetSubNodes(
nullptr, popOrZero(rNodeStack));
629 rNodeStack.push_front(std::move(pFontNode));
631 if (nFontSize != 0.0)
634 std::unique_ptr<SmFontNode> pFontNode(
new SmFontNode(aToken));
636 if (util::MeasureUnit::PERCENT
637 == rContext.GetSmImport().GetMM100UnitConverter().GetXMLMeasureUnit())
639 if (nFontSize < 100.00)
647 pFontNode->SetSubNodes(
nullptr, popOrZero(rNodeStack));
648 rNodeStack.push_front(std::move(pFontNode));
654 if (aSmColorTokenTableEntry.
eType ==
TRGB)
656 sal_uInt32(aSmColorTokenTableEntry.
cColor));
659 aToken = aSmColorTokenTableEntry;
660 std::unique_ptr<SmFontNode> pFontNode(
new SmFontNode(aToken));
661 pFontNode->SetSubNodes(
nullptr, popOrZero(rNodeStack));
662 rNodeStack.push_front(std::move(pFontNode));
666 if (sFontFamily.isEmpty())
669 if (sFontFamily.equalsIgnoreAsciiCase(
GetXMLToken(XML_FIXED)))
671 else if (sFontFamily.equalsIgnoreAsciiCase(
"sans"))
673 else if (sFontFamily.equalsIgnoreAsciiCase(
"serif"))
679 aToken.
aText = sFontFamily;
680 std::unique_ptr<SmFontNode> pFontNode(
new SmFontNode(aToken));
681 pFontNode->SetSubNodes(
nullptr, popOrZero(rNodeStack));
682 rNodeStack.push_front(std::move(pFontNode));
687class SmXMLTokenAttrHelper
694 SmXMLTokenAttrHelper(SmXMLImportContext& rContext)
701 void RetrieveAttrs(
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList);
706void SmXMLTokenAttrHelper::RetrieveAttrs(
707 const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
711 OUString sValue = aIter.toString();
712 switch (aIter.getToken())
716 SAL_WARN(
"starmath",
"failed to recognize mathvariant: " << sValue);
731 std::vector<SmTokenType> vVariant;
739 vVariant.push_back(
TBOLD);
746 vVariant.push_back(
TBOLD);
753 vVariant.push_back(
TBOLD);
760 vVariant.push_back(
TBOLD);
766 vVariant.push_back(
TSANS);
769 vVariant.push_back(
TSANS);
770 vVariant.push_back(
TBOLD);
774 vVariant.push_back(
TSANS);
778 vVariant.push_back(
TBOLD);
779 vVariant.push_back(
TSANS);
782 vVariant.push_back(
TFIXED);
791 if (vVariant.empty())
794 for (
auto eType : vVariant)
800 std::unique_ptr<SmFontNode> pFontNode(
new SmFontNode(aToken));
801 pFontNode->SetSubNodes(
nullptr, popOrZero(rNodeStack));
802 rNodeStack.push_front(std::move(pFontNode));
808class SmXMLDocContext_Impl :
public SmXMLImportContext
812 : SmXMLImportContext(rImport)
816 virtual uno::Reference<xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
817 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
override;
819 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
823class SmXMLRowContext_Impl :
public SmXMLDocContext_Impl
826 size_t nElementCount;
830 : SmXMLDocContext_Impl(rImport)
831 , nElementCount(GetSmImport().GetNodeStack().
size())
835 virtual uno::Reference<xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
836 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
override;
838 uno::Reference<xml::sax::XFastContextHandler> StrictCreateChildContext(sal_Int32 nElement);
840 virtual void SAL_CALL endFastElement(sal_Int32 nElement)
override;
843class SmXMLEncloseContext_Impl :
public SmXMLRowContext_Impl
849 : SmXMLRowContext_Impl(rImport)
853 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
857void SmXMLEncloseContext_Impl::endFastElement(sal_Int32 nElement)
864 if (GetSmImport().GetNodeStack().
size() - nElementCount != 1)
865 SmXMLRowContext_Impl::endFastElement(nElement);
870class SmXMLFracContext_Impl :
public SmXMLRowContext_Impl
875 : SmXMLRowContext_Impl(rImport)
879 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
882class SmXMLSqrtContext_Impl :
public SmXMLRowContext_Impl
886 : SmXMLRowContext_Impl(rImport)
890 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
893class SmXMLRootContext_Impl :
public SmXMLRowContext_Impl
897 : SmXMLRowContext_Impl(rImport)
901 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
904class SmXMLStyleContext_Impl :
public SmXMLRowContext_Impl
907 SmXMLContext_Helper aStyleHelper;
912 : SmXMLRowContext_Impl(rImport)
913 , aStyleHelper(*this)
917 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
918 void SAL_CALL startFastElement(
919 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
override;
923void SmXMLStyleContext_Impl::startFastElement(
924 sal_Int32 ,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
926 aStyleHelper.RetrieveAttrs(xAttrList);
929void SmXMLStyleContext_Impl::endFastElement(sal_Int32 nElement)
936 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
937 if (rNodeStack.size() - nElementCount != 1)
938 SmXMLRowContext_Impl::endFastElement(nElement);
939 aStyleHelper.ApplyAttrs();
944class SmXMLPaddedContext_Impl :
public SmXMLRowContext_Impl
949 : SmXMLRowContext_Impl(rImport)
953 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
957void SmXMLPaddedContext_Impl::endFastElement(sal_Int32 nElement)
964 if (GetSmImport().GetNodeStack().
size() - nElementCount != 1)
965 SmXMLRowContext_Impl::endFastElement(nElement);
970class SmXMLPhantomContext_Impl :
public SmXMLRowContext_Impl
975 : SmXMLRowContext_Impl(rImport)
979 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
983void SmXMLPhantomContext_Impl::endFastElement(sal_Int32 nElement)
990 if (GetSmImport().GetNodeStack().
size() - nElementCount != 1)
991 SmXMLRowContext_Impl::endFastElement(nElement);
998 std::unique_ptr<SmFontNode> pPhantom(
new SmFontNode(aToken));
999 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
1000 pPhantom->SetSubNodes(
nullptr, popOrZero(rNodeStack));
1001 rNodeStack.push_front(std::move(pPhantom));
1006class SmXMLFencedContext_Impl :
public SmXMLRowContext_Impl
1015 : SmXMLRowContext_Impl(rImport)
1018 , bIsStretchy(false)
1022 void SAL_CALL startFastElement(
1023 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
override;
1024 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
1028void SmXMLFencedContext_Impl::startFastElement(
1029 sal_Int32 ,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
1033 switch (aIter.getToken())
1037 cBegin = aIter.toString()[0];
1040 cEnd = aIter.toString()[0];
1053void SmXMLFencedContext_Impl::endFastElement(sal_Int32 )
1060 std::unique_ptr<SmStructureNode> pSNode(
new SmBraceNode(aToken));
1077 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
1081 auto i = rNodeStack.size() - nElementCount;
1082 if (rNodeStack.size() - nElementCount > 1)
1083 i += rNodeStack.size() - 1 - nElementCount;
1084 aRelationArray.resize(i);
1085 while (rNodeStack.size() > nElementCount)
1087 auto pNode = std::move(rNodeStack.front());
1088 rNodeStack.pop_front();
1089 aRelationArray[--
i] = pNode.release();
1090 if (i > 1 && rNodeStack.size() > 1)
1096 pBody->SetSubNodes(std::move(aRelationArray));
1098 pSNode->SetSubNodes(std::move(pLeft), std::move(pBody), std::move(pRight));
1102 GetSmImport().GetNodeStack().push_front(std::move(pSNode));
1107class SmXMLErrorContext_Impl :
public SmXMLRowContext_Impl
1111 : SmXMLRowContext_Impl(rImport)
1115 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
1119void SmXMLErrorContext_Impl::endFastElement(sal_Int32 )
1128 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
1129 while (rNodeStack.size() > nElementCount)
1131 rNodeStack.pop_front();
1137class SmXMLNumberContext_Impl :
public SmXMLImportContext
1144 : SmXMLImportContext(rImport)
1151 virtual void TCharacters(
const OUString& rChars)
override;
1153 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
1157void SmXMLNumberContext_Impl::TCharacters(
const OUString& rChars) { aToken.
aText = rChars; }
1159void SmXMLNumberContext_Impl::endFastElement(sal_Int32)
1161 GetSmImport().GetNodeStack().push_front(std::make_unique<SmTextNode>(aToken,
FNT_NUMBER));
1166class SmXMLAnnotationContext_Impl :
public SmXMLImportContext
1172 : SmXMLImportContext(rImport)
1173 , mnStarMathVersion(0)
1177 void SAL_CALL characters(
const OUString& rChars)
override;
1179 void SAL_CALL startFastElement(
1180 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
override;
1184void SmXMLAnnotationContext_Impl::startFastElement(
1185 sal_Int32 ,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
1190 switch (aIter.getToken() & TOKEN_MASK)
1194 = aIter.toView() ==
"StarMath 5.0" ? 5 : aIter.toView() ==
"StarMath 6" ? 6 : 0;
1203void SmXMLAnnotationContext_Impl::characters(
const OUString& rChars)
1205 if (mnStarMathVersion)
1207 GetSmImport().SetText(GetSmImport().GetText() + rChars);
1208 GetSmImport().SetSmSyntaxVersion(mnStarMathVersion);
1214class SmXMLTextContext_Impl :
public SmXMLImportContext
1221 : SmXMLImportContext(rImport)
1228 virtual void TCharacters(
const OUString& rChars)
override;
1230 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
1234void SmXMLTextContext_Impl::TCharacters(
const OUString& rChars) { aToken.
aText = rChars; }
1236void SmXMLTextContext_Impl::endFastElement(sal_Int32)
1238 GetSmImport().GetNodeStack().push_front(std::make_unique<SmTextNode>(aToken,
FNT_TEXT));
1243class SmXMLStringContext_Impl :
public SmXMLImportContext
1250 : SmXMLImportContext(rImport)
1257 virtual void TCharacters(
const OUString& rChars)
override;
1259 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
1263void SmXMLStringContext_Impl::TCharacters(
const OUString& rChars)
1275 aToken.
aText =
"\"" + rChars +
"\"";
1278void SmXMLStringContext_Impl::endFastElement(sal_Int32)
1280 GetSmImport().GetNodeStack().push_front(std::make_unique<SmTextNode>(aToken,
FNT_FIXED));
1285class SmXMLIdentifierContext_Impl :
public SmXMLImportContext
1287 SmXMLTokenAttrHelper maTokenAttrHelper;
1288 SmXMLContext_Helper aStyleHelper;
1293 : SmXMLImportContext(rImport)
1294 , maTokenAttrHelper(*this)
1295 , aStyleHelper(*this)
1302 void TCharacters(
const OUString& rChars)
override;
1304 startFastElement(sal_Int32 ,
1305 const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
override
1307 maTokenAttrHelper.RetrieveAttrs(xAttrList);
1308 aStyleHelper.RetrieveAttrs(xAttrList);
1310 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
1314void SmXMLIdentifierContext_Impl::endFastElement(sal_Int32)
1316 std::unique_ptr<SmTextNode> pNode;
1319 if (((aStyleHelper.nIsItalic == -1) && (aToken.
aText.getLength() > 1))
1320 || ((aStyleHelper.nIsItalic == 0) && (aToken.
aText.getLength() == 1)))
1323 pNode->GetFont().SetItalic(ITALIC_NONE);
1324 aStyleHelper.nIsItalic = -1;
1328 if (aStyleHelper.nIsItalic != -1)
1330 if (aStyleHelper.nIsItalic)
1331 pNode->GetFont().SetItalic(ITALIC_NORMAL);
1333 pNode->GetFont().SetItalic(ITALIC_NONE);
1334 aStyleHelper.nIsItalic = -1;
1336 GetSmImport().GetNodeStack().push_front(std::move(pNode));
1337 aStyleHelper.ApplyAttrs();
1343void SmXMLIdentifierContext_Impl::TCharacters(
const OUString& rChars) { aToken.
aText = rChars; }
1347class SmXMLOperatorContext_Impl :
public SmXMLImportContext
1349 SmXMLTokenAttrHelper maTokenAttrHelper;
1359 : SmXMLImportContext(rImport)
1360 , maTokenAttrHelper(*this)
1361 , bIsStretchy(false)
1371 void TCharacters(
const OUString& rChars)
override;
1372 void SAL_CALL startFastElement(
1373 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
override;
1374 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
1378void SmXMLOperatorContext_Impl::TCharacters(
const OUString& rChars)
1403void SmXMLOperatorContext_Impl::endFastElement(sal_Int32)
1411 GetSmImport().GetNodeStack().push_front(std::move(pNode));
1414 if (rtl::isAsciiAlpha(aToken.
cMathChar[0]))
1418void SmXMLOperatorContext_Impl::startFastElement(
1419 sal_Int32 ,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
1421 maTokenAttrHelper.RetrieveAttrs(xAttrList);
1425 switch (aIter.getToken())
1447class SmXMLSpaceContext_Impl :
public SmXMLImportContext
1451 : SmXMLImportContext(rImport)
1455 void SAL_CALL startFastElement(
1456 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
override;
1465 *pWide = *pNarrow = 0;
1474 auto aWide = rLV.
aNumber / aTwo;
1475 auto nWide =
static_cast<sal_Int32
>(
static_cast<tools::Long>(aWide));
1479 auto aNarrow = (rLV.
aNumber -
Fraction(nWide, 1) * aTwo) / aPointFive;
1480 auto nNarrow =
static_cast<sal_Int32
>(
static_cast<tools::Long>(aNarrow));
1489void SmXMLSpaceContext_Impl::startFastElement(
1490 sal_Int32 ,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
1494 sal_Int32 nWide = 0, nNarrow = 0;
1498 OUString sValue = aIter.toString();
1499 switch (aIter.getToken())
1503 || !lcl_CountBlanks(aLV, &nWide, &nNarrow))
1504 SAL_WARN(
"starmath",
"ignore mspace's width: " << sValue);
1516 std::unique_ptr<SmBlankNode> pBlank(
new SmBlankNode(aToken));
1518 pBlank->IncreaseBy(aToken, nWide);
1522 pBlank->IncreaseBy(aToken, nNarrow);
1524 GetSmImport().GetNodeStack().push_front(std::move(pBlank));
1529class SmXMLSubContext_Impl :
public SmXMLRowContext_Impl
1536 : SmXMLRowContext_Impl(rImport)
1540 void SAL_CALL endFastElement(sal_Int32)
override { GenericEndElement(
TRSUB,
RSUB); }
1547 const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 2;
1548 OSL_ENSURE(bNodeCheck,
"Sub has not two arguments");
1555 std::unique_ptr<SmSubSupNode> pNode(
new SmSubSupNode(aToken));
1556 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
1561 for (
size_t i = 1;
i < aSubNodes.size();
i++)
1562 aSubNodes[i] =
nullptr;
1564 aSubNodes[eSubSup + 1] = popOrZero(rNodeStack).release();
1565 aSubNodes[0] = popOrZero(rNodeStack).release();
1566 pNode->SetSubNodes(std::move(aSubNodes));
1567 rNodeStack.push_front(std::move(pNode));
1572class SmXMLSupContext_Impl :
public SmXMLSubContext_Impl
1576 : SmXMLSubContext_Impl(rImport)
1580 void SAL_CALL endFastElement(sal_Int32)
override { GenericEndElement(
TRSUP,
RSUP); }
1583class SmXMLSubSupContext_Impl :
public SmXMLRowContext_Impl
1590 : SmXMLRowContext_Impl(rImport)
1594 void SAL_CALL endFastElement(sal_Int32)
override { GenericEndElement(
TRSUB,
RSUB,
RSUP); }
1601 const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 3;
1602 OSL_ENSURE(bNodeCheck,
"SubSup has not three arguments");
1609 std::unique_ptr<SmSubSupNode> pNode(
new SmSubSupNode(aToken));
1610 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
1615 for (
size_t i = 1;
i < aSubNodes.size();
i++)
1616 aSubNodes[i] =
nullptr;
1618 aSubNodes[aSup + 1] = popOrZero(rNodeStack).release();
1619 aSubNodes[aSub + 1] = popOrZero(rNodeStack).release();
1620 aSubNodes[0] = popOrZero(rNodeStack).release();
1621 pNode->SetSubNodes(std::move(aSubNodes));
1622 rNodeStack.push_front(std::move(pNode));
1627class SmXMLUnderContext_Impl :
public SmXMLSubContext_Impl
1630 sal_Int16 nAttrCount;
1634 : SmXMLSubContext_Impl(rImport)
1639 void SAL_CALL startFastElement(
1640 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
override;
1641 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
1642 void HandleAccent();
1646void SmXMLUnderContext_Impl::startFastElement(
1647 sal_Int32 ,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
1654void SmXMLUnderContext_Impl::HandleAccent()
1656 const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 2;
1657 OSL_ENSURE(bNodeCheck,
"Sub has not two arguments");
1662 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
1663 std::unique_ptr<SmNode> pTest = popOrZero(rNodeStack);
1668 std::unique_ptr<SmNode> pFirst;
1670 if ((pTest->GetToken().cMathChar[0] & 0x0FFF) == 0x0332)
1675 pFirst = std::move(pTest);
1677 std::unique_ptr<SmNode> pSecond = popOrZero(rNodeStack);
1678 pNode->SetSubNodes(std::move(pFirst), std::move(pSecond));
1680 rNodeStack.push_front(std::move(pNode));
1683void SmXMLUnderContext_Impl::endFastElement(sal_Int32)
1693class SmXMLOverContext_Impl :
public SmXMLSubContext_Impl
1696 sal_Int16 nAttrCount;
1700 : SmXMLSubContext_Impl(rImport)
1705 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
1706 void SAL_CALL startFastElement(
1707 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
override;
1708 void HandleAccent();
1712void SmXMLOverContext_Impl::startFastElement(
1713 sal_Int32 ,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
1720void SmXMLOverContext_Impl::endFastElement(sal_Int32)
1728void SmXMLOverContext_Impl::HandleAccent()
1730 const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 2;
1731 OSL_ENSURE(bNodeCheck,
"Sub has not two arguments");
1740 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
1742 std::unique_ptr<SmNode> pFirst = popOrZero(rNodeStack);
1743 std::unique_ptr<SmNode> pSecond = popOrZero(rNodeStack);
1744 pNode->SetSubNodes(std::move(pFirst), std::move(pSecond));
1746 rNodeStack.push_front(std::move(pNode));
1751class SmXMLUnderOverContext_Impl :
public SmXMLSubSupContext_Impl
1755 : SmXMLSubSupContext_Impl(rImport)
1759 void SAL_CALL endFastElement(sal_Int32)
override { GenericEndElement(
TCSUB,
CSUB,
CSUP); }
1762class SmXMLMultiScriptsContext_Impl :
public SmXMLSubSupContext_Impl
1764 bool bHasPrescripts;
1766 void ProcessSubSupPairs(
bool bIsPrescript);
1769 SmXMLMultiScriptsContext_Impl(
SmXMLImport& rImport)
1770 : SmXMLSubSupContext_Impl(rImport)
1771 , bHasPrescripts(false)
1775 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
1776 virtual uno::Reference<xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
1777 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
override;
1780class SmXMLNoneContext_Impl :
public SmXMLImportContext
1784 : SmXMLImportContext(rImport)
1788 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
1792void SmXMLNoneContext_Impl::endFastElement(sal_Int32)
1796 aToken.
aText.clear();
1799 GetSmImport().GetNodeStack().push_front(std::make_unique<SmTextNode>(aToken,
FNT_VARIABLE));
1804class SmXMLPrescriptsContext_Impl :
public SmXMLImportContext
1808 : SmXMLImportContext(rImport)
1813class SmXMLTableRowContext_Impl :
public SmXMLRowContext_Impl
1817 : SmXMLRowContext_Impl(rImport)
1821 virtual uno::Reference<xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
1822 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
override;
1825class SmXMLTableContext_Impl :
public SmXMLTableRowContext_Impl
1829 : SmXMLTableRowContext_Impl(rImport)
1833 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
1834 virtual uno::Reference<xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
1835 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
override;
1838class SmXMLTableCellContext_Impl :
public SmXMLRowContext_Impl
1842 : SmXMLRowContext_Impl(rImport)
1847class SmXMLAlignGroupContext_Impl :
public SmXMLRowContext_Impl
1851 : SmXMLRowContext_Impl(rImport)
1858class SmXMLActionContext_Impl :
public SmXMLRowContext_Impl
1864 : SmXMLRowContext_Impl(rImport)
1869 void SAL_CALL startFastElement(
1870 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
override;
1871 void SAL_CALL endFastElement(sal_Int32 nElement)
override;
1886 const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList)
override;
1890uno::Reference<xml::sax::XFastContextHandler> SmXMLOfficeContext_Impl::createFastChildContext(
1891 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& )
1896 "XML_TOK_DOC_META: should not have come here, maybe document is invalid?");
1898 else if (nElement ==
XML_ELEMENT(OFFICE, XML_SETTINGS))
1912 const uno::Reference<document::XDocumentProperties>& i_xDocProps);
1916 const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList)
override;
1920SmXMLFlatDocContext_Impl::SmXMLFlatDocContext_Impl(
1921 SmXMLImport& i_rImport,
const uno::Reference<document::XDocumentProperties>& i_xDocProps)
1923 , SmXMLOfficeContext_Impl(i_rImport)
1928uno::Reference<xml::sax::XFastContextHandler>
1929 SAL_CALL SmXMLFlatDocContext_Impl::createFastChildContext(
1930 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
1939 return SmXMLOfficeContext_Impl::createFastChildContext(nElement, xAttrList);
1943uno::Reference<xml::sax::XFastContextHandler> SmXMLDocContext_Impl::createFastChildContext(
1944 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& )
1946 uno::Reference<xml::sax::XFastContextHandler> xContext;
1952 xContext = new SmXMLRowContext_Impl(GetSmImport());
1956 xContext = new SmXMLRowContext_Impl(GetSmImport());
1959 xContext = new SmXMLEncloseContext_Impl(GetSmImport());
1962 xContext = new SmXMLFracContext_Impl(GetSmImport());
1965 xContext = new SmXMLSqrtContext_Impl(GetSmImport());
1968 xContext = new SmXMLRootContext_Impl(GetSmImport());
1971 xContext = new SmXMLStyleContext_Impl(GetSmImport());
1974 xContext = new SmXMLErrorContext_Impl(GetSmImport());
1977 xContext = new SmXMLPaddedContext_Impl(GetSmImport());
1980 xContext = new SmXMLPhantomContext_Impl(GetSmImport());
1983 xContext = new SmXMLFencedContext_Impl(GetSmImport());
1987 xContext = new SmXMLSubContext_Impl(GetSmImport());
1990 xContext = new SmXMLSupContext_Impl(GetSmImport());
1993 xContext = new SmXMLSubSupContext_Impl(GetSmImport());
1996 xContext = new SmXMLUnderContext_Impl(GetSmImport());
1999 xContext = new SmXMLOverContext_Impl(GetSmImport());
2002 xContext = new SmXMLUnderOverContext_Impl(GetSmImport());
2005 xContext = new SmXMLMultiScriptsContext_Impl(GetSmImport());
2008 xContext = new SmXMLTableContext_Impl(GetSmImport());
2011 xContext = new SmXMLActionContext_Impl(GetSmImport());
2018 new SmXMLRowContext_Impl(GetSmImport()));
2020 xContext = aTempContext->StrictCreateChildContext(nElement);
2026void SmXMLDocContext_Impl::endFastElement(sal_Int32)
2028 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
2030 std::unique_ptr<SmNode> pContextNode = popOrZero(rNodeStack);
2033 std::unique_ptr<SmStructureNode> pSNode(
new SmLineNode(aDummy));
2034 pSNode->SetSubNodes(std::move(pContextNode),
nullptr);
2035 rNodeStack.push_front(std::move(pSNode));
2038 auto n = rNodeStack.size();
2039 LineArray.resize(n);
2040 for (
size_t j = 0; j <
n; j++)
2042 auto pNode = std::move(rNodeStack.front());
2043 rNodeStack.pop_front();
2044 LineArray[
n - (j + 1)] = pNode.release();
2046 std::unique_ptr<SmStructureNode> pSNode2(
new SmTableNode(aDummy));
2047 pSNode2->SetSubNodes(std::move(LineArray));
2048 rNodeStack.push_front(std::move(pSNode2));
2051void SmXMLFracContext_Impl::endFastElement(sal_Int32)
2053 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
2054 const bool bNodeCheck = rNodeStack.size() - nElementCount == 2;
2055 OSL_ENSURE(bNodeCheck,
"Fraction (mfrac) tag is missing component");
2062 std::unique_ptr<SmStructureNode> pSNode(
new SmBinVerNode(aToken));
2064 std::unique_ptr<SmNode> pSecond = popOrZero(rNodeStack);
2065 std::unique_ptr<SmNode> pFirst = popOrZero(rNodeStack);
2066 pSNode->SetSubNodes(std::move(pFirst), std::move(pOper), std::move(pSecond));
2067 rNodeStack.push_front(std::move(pSNode));
2070void SmXMLRootContext_Impl::endFastElement(sal_Int32)
2073 const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 2;
2074 OSL_ENSURE(bNodeCheck,
"Root tag is missing component");
2081 std::unique_ptr<SmStructureNode> pSNode(
new SmRootNode(aToken));
2083 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
2084 std::unique_ptr<SmNode> pIndex = popOrZero(rNodeStack);
2085 std::unique_ptr<SmNode> pBase = popOrZero(rNodeStack);
2086 pSNode->SetSubNodes(std::move(pIndex), std::move(pOper), std::move(pBase));
2087 rNodeStack.push_front(std::move(pSNode));
2090void SmXMLSqrtContext_Impl::endFastElement(sal_Int32 nElement)
2097 if (GetSmImport().GetNodeStack().
size() - nElementCount != 1)
2098 SmXMLRowContext_Impl::endFastElement(nElement);
2103 std::unique_ptr<SmStructureNode> pSNode(
new SmRootNode(aToken));
2105 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
2106 pSNode->SetSubNodes(
nullptr, std::move(pOper), popOrZero(rNodeStack));
2107 rNodeStack.push_front(std::move(pSNode));
2110void SmXMLRowContext_Impl::endFastElement(sal_Int32)
2113 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
2115 if (rNodeStack.size() > nElementCount)
2117 auto nSize = rNodeStack.size() - nElementCount;
2119 aRelationArray.resize(nSize);
2120 for (
auto j = nSize; j > 0; j--)
2122 auto pNode = std::move(rNodeStack.front());
2123 rNodeStack.pop_front();
2124 aRelationArray[j - 1] = pNode.release();
2141 int nLeft = 0, nRight = 0;
2145 aToken = aRelationArray[0]->GetToken();
2157 aToken = aRelationArray[nSize - 1]->GetToken();
2169 int nRelArrSize = nSize - nLeft - nRight;
2170 if (nRelArrSize > 0)
2172 aRelationArray2.resize(nRelArrSize);
2173 for (
int i = 0;
i < nRelArrSize;
i++)
2175 aRelationArray2[
i] = aRelationArray[
i + nLeft];
2176 aRelationArray[
i + nLeft] =
nullptr;
2181 std::unique_ptr<SmStructureNode> pSNode(
new SmBraceNode(aToken));
2183 pBody->SetSubNodes(std::move(aRelationArray2));
2185 pSNode->SetSubNodes(std::move(pLeft), std::move(pBody), std::move(pRight));
2187 rNodeStack.push_front(std::move(pSNode));
2189 for (
auto a : aRelationArray)
2201 aRelationArray.resize(2);
2220 pSNode->SetSubNodes(std::move(aRelationArray));
2221 rNodeStack.push_front(std::move(pSNode));
2224uno::Reference<xml::sax::XFastContextHandler>
2225SmXMLRowContext_Impl::StrictCreateChildContext(sal_Int32 nElement)
2227 uno::Reference<xml::sax::XFastContextHandler> pContext;
2233 pContext = new SmXMLNumberContext_Impl(GetSmImport());
2236 pContext = new SmXMLIdentifierContext_Impl(GetSmImport());
2239 pContext = new SmXMLOperatorContext_Impl(GetSmImport());
2242 pContext = new SmXMLTextContext_Impl(GetSmImport());
2245 pContext = new SmXMLSpaceContext_Impl(GetSmImport());
2248 pContext = new SmXMLStringContext_Impl(GetSmImport());
2254 pContext = new SmXMLAlignGroupContext_Impl(GetSmImport());
2258 pContext = new SmXMLAnnotationContext_Impl(GetSmImport());
2267uno::Reference<xml::sax::XFastContextHandler> SmXMLRowContext_Impl::createFastChildContext(
2268 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
2270 uno::Reference<xml::sax::XFastContextHandler> xContext = StrictCreateChildContext(nElement);
2276 xContext = SmXMLDocContext_Impl::createFastChildContext(nElement, xAttrList);
2281uno::Reference<xml::sax::XFastContextHandler> SmXMLMultiScriptsContext_Impl::createFastChildContext(
2282 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
2284 uno::Reference<xml::sax::XFastContextHandler> xContext;
2289 bHasPrescripts = true;
2290 ProcessSubSupPairs(
false);
2291 xContext =
new SmXMLPrescriptsContext_Impl(GetSmImport());
2294 xContext = new SmXMLNoneContext_Impl(GetSmImport());
2297 xContext = SmXMLRowContext_Impl::createFastChildContext(nElement, xAttrList);
2303void SmXMLMultiScriptsContext_Impl::ProcessSubSupPairs(
bool bIsPrescript)
2305 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
2307 if (rNodeStack.size() <= nElementCount)
2310 auto nCount = rNodeStack.size() - nElementCount - 1;
2314 if (nCount % 2 == 0)
2321 for (
size_t i = 0;
i <
nCount + 1;
i++)
2323 auto pNode = std::move(rNodeStack.front());
2324 rNodeStack.pop_front();
2325 aReverseStack.push_front(std::move(pNode));
2331 for (
size_t i = 0;
i <
nCount;
i += 2)
2333 std::unique_ptr<SmSubSupNode> pNode(
new SmSubSupNode(aToken));
2341 aSubNodes[0] = popOrZero(aReverseStack).release();
2343 std::unique_ptr<SmNode> pScriptNode = popOrZero(aReverseStack);
2346 && ((pScriptNode->GetToken().eType !=
TIDENT)
2347 || (!pScriptNode->GetToken().aText.isEmpty())))
2348 aSubNodes[eSub + 1] = pScriptNode.release();
2349 pScriptNode = popOrZero(aReverseStack);
2351 && ((pScriptNode->GetToken().eType !=
TIDENT)
2352 || (!pScriptNode->GetToken().aText.isEmpty())))
2353 aSubNodes[eSup + 1] = pScriptNode.release();
2355 pNode->SetSubNodes(std::move(aSubNodes));
2356 aReverseStack.push_front(std::move(pNode));
2358 assert(!aReverseStack.empty());
2359 auto pNode = std::move(aReverseStack.front());
2360 aReverseStack.pop_front();
2361 rNodeStack.push_front(std::move(pNode));
2366 for (
size_t i = 0;
i <
nCount;
i++)
2368 rNodeStack.pop_front();
2373void SmXMLTableContext_Impl::endFastElement(sal_Int32)
2376 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
2378 aExpressionArray.resize(rNodeStack.size() - nElementCount);
2380 size_t nRows = rNodeStack.size() - nElementCount;
2383 for (
size_t i = nRows;
i > 0; --
i)
2385 SmNode* pArray = rNodeStack.front().release();
2386 rNodeStack.pop_front();
2398 aRelationArray.resize(1);
2399 aRelationArray[0] = pArray;
2402 pExprNode->
SetSubNodes(std::move(aRelationArray));
2407 aReverseStack.push_front(std::unique_ptr<SmNode>(pArray));
2409 if (nCols > SAL_MAX_UINT16)
2410 throw std::range_error(
"column limit");
2411 if (nRows > SAL_MAX_UINT16)
2412 throw std::range_error(
"row limit");
2413 aExpressionArray.resize(nCols * nRows);
2415 for (
auto& elem : aReverseStack)
2417 std::unique_ptr<SmStructureNode> xArray(
static_cast<SmStructureNode*
>(elem.release()));
2418 for (
size_t i = 0;
i < xArray->GetNumSubNodes(); ++
i)
2419 aExpressionArray[j++] = xArray->GetSubNode(i);
2420 xArray->ClearSubNodes();
2422 aReverseStack.clear();
2427 std::unique_ptr<SmMatrixNode> pSNode(
new SmMatrixNode(aToken));
2428 pSNode->SetSubNodes(std::move(aExpressionArray));
2429 pSNode->SetRowCol(nRows, nCols);
2430 rNodeStack.push_front(std::move(pSNode));
2433uno::Reference<xml::sax::XFastContextHandler> SmXMLTableRowContext_Impl::createFastChildContext(
2434 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
2436 uno::Reference<xml::sax::XFastContextHandler> xContext;
2441 xContext = new SmXMLTableCellContext_Impl(GetSmImport());
2444 xContext = SmXMLRowContext_Impl::createFastChildContext(nElement, xAttrList);
2450uno::Reference<xml::sax::XFastContextHandler> SmXMLTableContext_Impl::createFastChildContext(
2451 sal_Int32 nElement,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
2453 uno::Reference<xml::sax::XFastContextHandler> xContext;
2458 xContext = new SmXMLTableRowContext_Impl(GetSmImport());
2461 xContext = SmXMLTableRowContext_Impl::createFastChildContext(nElement, xAttrList);
2467void SmXMLMultiScriptsContext_Impl::endFastElement(sal_Int32)
2469 ProcessSubSupPairs(bHasPrescripts);
2472void SmXMLActionContext_Impl::startFastElement(
2473 sal_Int32 ,
const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
2477 switch (aIter.getToken())
2481 sal_Int32
n = aIter.toInt32();
2483 mnSelection =
static_cast<size_t>(
n);
2493void SmXMLActionContext_Impl::endFastElement(sal_Int32)
2495 SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
2496 auto nSize = rNodeStack.size();
2497 if (nSize <= nElementCount)
2502 assert(mnSelection > 0);
2503 if (nSize < nElementCount + mnSelection)
2509 assert(nSize >= nElementCount + mnSelection);
2510 for (
auto i = nSize - (nElementCount + mnSelection);
i > 0;
i--)
2512 rNodeStack.pop_front();
2514 auto pSelected = std::move(rNodeStack.front());
2515 rNodeStack.pop_front();
2516 for (
auto i = rNodeStack.size() - nElementCount; i > 0; i--)
2518 rNodeStack.pop_front();
2520 rNodeStack.push_front(std::move(pSelected));
2525 const uno::Reference<xml::sax::XFastAttributeList>& )
2534 uno::Reference<document::XDocumentPropertiesSupplier> xDPS(GetModel(),
2535 uno::UNO_QUERY_THROW);
2539 :
new SmXMLFlatDocContext_Impl(*
this, xDPS->getDocumentProperties());
2544 pContext =
new SmXMLOfficeContext_Impl(*
this);
2546 pContext =
new SmXMLDocContext_Impl(*
this);
2555 uno::Reference<frame::XModel>
xModel = GetModel();
2572 for (
const PropertyValue& rValue : aViewProps)
2574 if (rValue.Name ==
"ViewAreaTop")
2576 rValue.Value >>= nTmp;
2579 else if (rValue.Name ==
"ViewAreaLeft")
2581 rValue.Value >>= nTmp;
2584 else if (rValue.Name ==
"ViewAreaWidth")
2586 rValue.Value >>= nTmp;
2591 else if (rValue.Name ==
"ViewAreaHeight")
2593 rValue.Value >>= nTmp;
2605 uno::Reference<XPropertySet> xProps(GetModel(), UNO_QUERY);
2609 Reference<XPropertySetInfo> xInfo(xProps->getPropertySetInfo());
2613 static constexpr OUStringLiteral
sFormula(
u"Formula");
2614 static constexpr OUStringLiteral sBasicLibraries(
u"BasicLibraries");
2615 static constexpr OUStringLiteral sDialogLibraries(
u"DialogLibraries");
2616 for (
const PropertyValue& rValue : aConfProps)
2618 if (rValue.Name !=
sFormula && rValue.Name != sBasicLibraries
2619 && rValue.Name != sDialogLibraries)
2623 if (xInfo->hasPropertyByName(rValue.Name))
2624 xProps->setPropertyValue(rValue.Name, rValue.Value);
2626 catch (
const beans::PropertyVetoException&)
2646 uno::Reference<beans::XPropertySet> xInfoSet;
2661 "com.sun.star.comp.Math.XMLImporter",
false,
const NodeContext & mrContext
virtual bool IsImportSymbolNames() const =0
virtual void SetImportSymbolNames(bool bVal)=0
virtual std::unique_ptr< SmTableNode > Parse(const OUString &rBuffer)=0
Parse rBuffer to formula tree.
virtual const OUString & GetText() const =0
const OUString & GetValue() const
sal_Int32 GetNumerator() const
SfxObjectShell * GetObjectShell() const
const SfxPoolItem * GetItem(sal_uInt16 nWhich, bool bSearchInParent=true) const
OUString GetBaseURL(bool bForSaving=false)
SfxItemSet & GetItemSet() const
css::uno::Reference< css::embed::XStorage > GetStorage(bool bCreateTempFile=true)
SfxMedium * GetMedium() const
css::uno::Reference< css::frame::XModel3 > GetModel() const
void SetLoading(SfxLoadedFlags nFlags)
virtual tools::Rectangle GetVisArea(sal_uInt16 nAspect) const
SfxObjectCreateMode GetCreateMode() const
const css::uno::Any & GetValue() const
void setWidth(tools::Long nWidth)
void setHeight(tools::Long nHeight)
Node for brace construction.
void SetText(const OUString &rBuffer)
virtual void SetVisArea(const tools::Rectangle &rVisArea) override
void SetSmSyntaxVersion(sal_uInt16 nSmSyntaxVersion)
AbstractSmParser * GetParser()
void SetFormulaTree(SmTableNode *pTree)
Glyph node for custom operators.
Extract command text from pNodes.
virtual size_t GetNumSubNodes() const =0
Gets the number of subnodes.
Abstract baseclass for all composite node.
void SetSubNodes(std::unique_ptr< SmNode > pFirst, std::unique_ptr< SmNode > pSecond, std::unique_ptr< SmNode > pThird=nullptr)
Sets subnodes, used for operators.
Super- and subscript node.
bool m_bUseHTMLMLEntities
ErrCode Import(SfxMedium &rMedium)
rtl::Reference< SmModel > m_xModel
static ErrCode ReadThroughComponent(const css::uno::Reference< css::io::XInputStream > &xInputStream, const css::uno::Reference< css::lang::XComponent > &xModelComponent, css::uno::Reference< css::uno::XComponentContext > const &rxContext, css::uno::Reference< css::beans::XPropertySet > const &rPropSet, const char *pFilterName, bool bEncrypted, bool bUseHTMLMLEntities)
SmXMLImport(const css::uno::Reference< css::uno::XComponentContext > &rContext, OUString const &implementationName, SvXMLImportFlags nImportFlags)
virtual ~SmXMLImport() noexcept override
SvXMLImportContext * CreateFastContext(sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList > &xAttrList) override
void SAL_CALL endDocument() override
virtual void SetViewSettings(const css::uno::Sequence< css::beans::PropertyValue > &aViewProps) override
virtual void SetConfigurationSettings(const css::uno::Sequence< css::beans::PropertyValue > &aViewProps) override
sal_uInt16 mnSmSyntaxVersion
sal_Int32 GetVersion() const
virtual void SAL_CALL startFastElement(sal_Int32 Element, const css::uno::Reference< css::xml::sax::XFastAttributeList > &Attribs) override
SvXMLImport & GetImport()
virtual css::uno::Reference< XFastContextHandler > SAL_CALL createFastChildContext(sal_Int32 Element, const css::uno::Reference< css::xml::sax::XFastAttributeList > &Attribs) override
virtual void SAL_CALL characters(const OUString &aChars) override
virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList > &xAttrList) override
css::uno::Type const & get()
static void convertDouble(OUStringBuffer &rBuffer, double fNumber, bool bWriteUnits, sal_Int16 nSourceUnit, sal_Int16 nTargetUnit)
const std::vector< sal_Int32 > & getFastAttributeTokens() const
constexpr OUStringLiteral sColor
#define DBG_UNHANDLED_EXCEPTION(...)
SVXCORE_DLLPUBLIC OUString SvxResId(TranslateId aId)
#define ERRCODE_IO_BROKENPACKAGE
#define SAL_INFO_IF(condition, area, stream)
#define SAL_WARN_IF(condition, area, stream)
#define SAL_WARN(area, stream)
bool ParseMathMLAttributeLengthValue(std::u16string_view rStr, MathMLAttributeLengthValue &rV)
bool GetMathMLMathvariantValue(const OUString &rStr, MathMLMathvariantValue &rV)
SAL_DLLPUBLIC_EXPORT uno::XInterface * Math_XMLImporter_get_implementation(uno::XComponentContext *pCtx, uno::Sequence< uno::Any > const &)
SAL_DLLPUBLIC_EXPORT bool TestImportMML(SvStream &rStream)
SAL_DLLPUBLIC_EXPORT uno::XInterface * Math_XMLOasisMetaImporter_get_implementation(uno::XComponentContext *pCtx, uno::Sequence< uno::Any > const &)
SAL_DLLPUBLIC_EXPORT uno::XInterface * Math_XMLOasisSettingsImporter_get_implementation(uno::XComponentContext *pCtx, uno::Sequence< uno::Any > const &)
std::deque< std::unique_ptr< SmNode > > SmNodeStack
tDoubleVectorPair cleanup(const css::uno::Sequence< double > &rXValues, const css::uno::Sequence< double > &rYValues, Pred aPred)
COMPHELPER_DLLPUBLIC css::uno::Reference< css::beans::XPropertySet > GenericPropertySet_CreateInstance(PropertySetInfo *pInfo)
Reference< XComponentContext > getProcessComponentContext()
constexpr OUStringLiteral implementationName
std::basic_string_view< charT, traits > trim(std::basic_string_view< charT, traits > str)
FastAttributeList & castToFastAttributeList(const css::uno::Reference< css::xml::sax::XFastAttributeList > &xAttrList)
const ::css::uno::Sequence<::css::beans::Pair<::rtl::OUString, ::rtl::OUString > > icustomMathmlHtmlEntities
Entity names for mathml.
SmToken Identify_SmXMLOperatorContext_Impl(sal_Unicode cChar, bool bIsStretchy=true)
Identifies operator chars tokens for importing mathml.
SmColorTokenTableEntry Identify_Color_Parser(sal_uInt32 cColor)
Identifies color from color code cColor.
SmToken Identify_PrefixPostfix_SmXMLOperatorContext_Impl(sal_Unicode cChar)
Identifies opening / closing brace tokens for importing mathml.
SmColorTokenTableEntry Identify_ColorName_HTML(std::u16string_view colorname)
Identifies color from color name.
SmToken Identify_Postfix_SmXMLOperatorContext_Impl(sal_Unicode cChar)
Identifies closing brace tokens for importing mathml.
SmToken Identify_Prefix_SmXMLOperatorContext_Impl(sal_Unicode cChar)
Identifies opening brace tokens for importing mathml.
bool IsXMLToken(std::u16string_view rString, enum XMLTokenEnum eToken)
const OUString & GetXMLToken(enum XMLTokenEnum eToken)
std::vector< SmNode * > SmNodeArray
SmSubSup
Enum used to index sub-/supscripts in the 'maSubNodes' array in 'SmSubSupNode'.
#define SUBSUP_NUM_ENTRIES
numbers of entries in the above enum (that is: the number of possible sub-/supscripts)
#define ERRCODE_SFX_WRONGPASSWORD
#define ERRCODE_SFX_DOLOADFAILED
void setChar(sal_Unicode cChar)
Reference< XModel > xModel
sal_Unicode const MS_RPARENT
sal_Unicode const MS_RBRACE
sal_Unicode const MS_SQRT
sal_Unicode const MS_LBRACE
sal_Unicode const MS_LPARENT
sal_Unicode const MS_VERTLINE
#define XMLOFF_WARN_UNKNOWN(area, rIter)
#define XML_ELEMENT(prefix, name)
constexpr bool IsTokenInNamespace(sal_Int32 nToken, sal_uInt16 nNamespacePrefix)
constexpr sal_Int32 TOKEN_MASK
constexpr sal_uInt16 XML_NAMESPACE_OFFICE