LCOV - code coverage report
Current view: top level - libreoffice/starmath/source - mathmlimport.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 7 1266 0.6 %
Date: 2012-12-27 Functions: 5 232 2.2 %
Legend: Lines: hit not hit

          Line data    Source code
       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             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : /*todo: Change characters and tcharacters to accumulate the characters together
      22             : into one string, xml parser hands them to us line by line rather than all in
      23             : one go*/
      24             : 
      25             : #include <com/sun/star/xml/sax/XErrorHandler.hpp>
      26             : #include <com/sun/star/xml/sax/XEntityResolver.hpp>
      27             : #include <com/sun/star/xml/sax/InputSource.hpp>
      28             : #include <com/sun/star/xml/sax/XDTDHandler.hpp>
      29             : #include <com/sun/star/xml/sax/Parser.hpp>
      30             : #include <com/sun/star/io/XActiveDataSource.hpp>
      31             : #include <com/sun/star/io/XActiveDataControl.hpp>
      32             : #include <com/sun/star/document/XDocumentProperties.hpp>
      33             : #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
      34             : #include <com/sun/star/packages/zip/ZipIOException.hpp>
      35             : #include <com/sun/star/task/XStatusIndicatorFactory.hpp>
      36             : #include <com/sun/star/beans/PropertyAttribute.hpp>
      37             : #include <com/sun/star/container/XNameAccess.hpp>
      38             : #include <com/sun/star/embed/ElementModes.hpp>
      39             : #include <com/sun/star/uno/Any.h>
      40             : 
      41             : #include <comphelper/componentcontext.hxx>
      42             : #include <comphelper/genericpropertyset.hxx>
      43             : #include <comphelper/processfactory.hxx>
      44             : #include <comphelper/servicehelper.hxx>
      45             : #include <comphelper/string.hxx>
      46             : #include <rtl/math.hxx>
      47             : #include <sfx2/frame.hxx>
      48             : #include <sfx2/docfile.hxx>
      49             : #include <osl/diagnose.h>
      50             : #include <svtools/sfxecode.hxx>
      51             : #include <unotools/saveopt.hxx>
      52             : #include <svl/stritem.hxx>
      53             : #include <svl/itemprop.hxx>
      54             : #include <unotools/streamwrap.hxx>
      55             : #include <sax/tools/converter.hxx>
      56             : #include <xmloff/xmlnmspe.hxx>
      57             : #include <xmloff/xmltoken.hxx>
      58             : #include <xmloff/nmspmap.hxx>
      59             : #include <xmloff/attrlist.hxx>
      60             : #include <xmloff/xmluconv.hxx>
      61             : #include <xmloff/xmlmetai.hxx>
      62             : #include <osl/mutex.hxx>
      63             : 
      64             : #include <memory>
      65             : 
      66             : #include "mathmlimport.hxx"
      67             : #include <starmath.hrc>
      68             : #include <unomodel.hxx>
      69             : #include <document.hxx>
      70             : #include <utility.hxx>
      71             : 
      72             : using namespace ::com::sun::star::beans;
      73             : using namespace ::com::sun::star::container;
      74             : using namespace ::com::sun::star::document;
      75             : using namespace ::com::sun::star::lang;
      76             : using namespace ::com::sun::star::uno;
      77             : using namespace ::com::sun::star;
      78             : using namespace ::xmloff::token;
      79             : 
      80             : using ::rtl::OUString;
      81             : using ::rtl::OUStringBuffer;
      82             : 
      83             : #define IMPORT_SVC_NAME "com.sun.star.xml.XMLImportFilter"
      84             : 
      85             : #undef WANTEXCEPT
      86             : 
      87             : ////////////////////////////////////////////////////////////
      88             : 
      89             : namespace {
      90             : template < typename T >
      91           0 : T* lcl_popOrZero( ::std::stack<T*> & rStack )
      92             : {
      93           0 :     if (rStack.empty())
      94           0 :         return 0;
      95           0 :     T* pTmp = rStack.top();
      96           0 :     rStack.pop();
      97           0 :     return pTmp;
      98             : }
      99             : }
     100             : 
     101           0 : sal_uLong SmXMLImportWrapper::Import(SfxMedium &rMedium)
     102             : {
     103           0 :     sal_uLong nError = ERRCODE_SFX_DOLOADFAILED;
     104             : 
     105             :     uno::Reference<lang::XMultiServiceFactory> xServiceFactory(
     106           0 :         comphelper::getProcessServiceFactory());
     107             :     OSL_ENSURE(xServiceFactory.is(), "XMLReader::Read: got no service manager");
     108           0 :     if ( !xServiceFactory.is() )
     109           0 :         return nError;
     110             : 
     111             :     //Make a model component from our SmModel
     112           0 :     uno::Reference< lang::XComponent > xModelComp( xModel, uno::UNO_QUERY );
     113             :     OSL_ENSURE( xModelComp.is(), "XMLReader::Read: got no model" );
     114             : 
     115             :     // try to get an XStatusIndicator from the Medium
     116           0 :     uno::Reference<task::XStatusIndicator> xStatusIndicator;
     117             : 
     118           0 :     sal_Bool bEmbedded = sal_False;
     119           0 :     uno::Reference <lang::XUnoTunnel> xTunnel;
     120           0 :     xTunnel = uno::Reference <lang::XUnoTunnel> (xModel,uno::UNO_QUERY);
     121             :     SmModel *pModel = reinterpret_cast<SmModel *>
     122           0 :         (xTunnel->getSomething(SmModel::getUnoTunnelId()));
     123             : 
     124             :     SmDocShell *pDocShell = pModel ?
     125           0 :             static_cast<SmDocShell*>(pModel->GetObjectShell()) : 0;
     126           0 :     if (pDocShell)
     127             :     {
     128             :         OSL_ENSURE( pDocShell->GetMedium() == &rMedium,
     129             :                 "different SfxMedium found" );
     130             : 
     131           0 :         SfxItemSet* pSet = rMedium.GetItemSet();
     132           0 :         if (pSet)
     133             :         {
     134             :             const SfxUnoAnyItem* pItem = static_cast<const SfxUnoAnyItem*>(
     135           0 :                 pSet->GetItem(SID_PROGRESS_STATUSBAR_CONTROL) );
     136           0 :             if (pItem)
     137           0 :                 pItem->GetValue() >>= xStatusIndicator;
     138             :         }
     139             : 
     140           0 :         if ( SFX_CREATE_MODE_EMBEDDED == pDocShell->GetCreateMode() )
     141           0 :             bEmbedded = sal_True;
     142             :     }
     143             : 
     144             :     comphelper::PropertyMapEntry aInfoMap[] =
     145             :     {
     146             :         { "PrivateData", sizeof("PrivateData")-1, 0,
     147           0 :               &::getCppuType( (Reference<XInterface> *)0 ),
     148             :               beans::PropertyAttribute::MAYBEVOID, 0 },
     149             :         { "BaseURI", sizeof("BaseURI")-1, 0,
     150           0 :               &::getCppuType( (OUString *)0 ),
     151             :               beans::PropertyAttribute::MAYBEVOID, 0 },
     152             :         { "StreamRelPath", sizeof("StreamRelPath")-1, 0,
     153           0 :               &::getCppuType( (OUString *)0 ),
     154             :               beans::PropertyAttribute::MAYBEVOID, 0 },
     155             :         { "StreamName", sizeof("StreamName")-1, 0,
     156           0 :               &::getCppuType( (OUString *)0 ),
     157             :               beans::PropertyAttribute::MAYBEVOID, 0 },
     158             :         { NULL, 0, 0, NULL, 0, 0 }
     159           0 :     };
     160             :     uno::Reference< beans::XPropertySet > xInfoSet(
     161             :                 comphelper::GenericPropertySet_CreateInstance(
     162           0 :                             new comphelper::PropertySetInfo( aInfoMap ) ) );
     163             : 
     164             :     // Set base URI
     165           0 :     OUString sPropName( "BaseURI" );
     166           0 :     xInfoSet->setPropertyValue( sPropName, makeAny( rMedium.GetBaseURL() ) );
     167             : 
     168           0 :     sal_Int32 nSteps=3;
     169           0 :     if ( !(rMedium.IsStorage()))
     170           0 :         nSteps = 1;
     171             : 
     172           0 :     sal_Int32 nProgressRange(nSteps);
     173           0 :     if (xStatusIndicator.is())
     174             :     {
     175           0 :         xStatusIndicator->start(SM_RESSTR(STR_STATSTR_READING), nProgressRange);
     176             :     }
     177             : 
     178           0 :     nSteps=0;
     179           0 :     if (xStatusIndicator.is())
     180           0 :         xStatusIndicator->setValue(nSteps++);
     181             : 
     182           0 :     if ( rMedium.IsStorage())
     183             :     {
     184             :         // TODO/LATER: handle the case of embedded links gracefully
     185           0 :         if ( bEmbedded ) // && !rMedium.GetStorage()->IsRoot() )
     186             :         {
     187           0 :             OUString aName( "dummyObjName" );
     188           0 :             if ( rMedium.GetItemSet() )
     189             :             {
     190             :                 const SfxStringItem* pDocHierarchItem = static_cast<const SfxStringItem*>(
     191           0 :                     rMedium.GetItemSet()->GetItem(SID_DOC_HIERARCHICALNAME) );
     192           0 :                 if ( pDocHierarchItem )
     193           0 :                     aName = pDocHierarchItem->GetValue();
     194             :             }
     195             : 
     196           0 :             if ( !aName.isEmpty() )
     197             :             {
     198           0 :                 sPropName = "StreamRelPath";
     199           0 :                 xInfoSet->setPropertyValue( sPropName, makeAny( aName ) );
     200           0 :             }
     201             :         }
     202             : 
     203           0 :         sal_Bool bOASIS = ( SotStorage::GetVersion( rMedium.GetStorage() ) > SOFFICE_FILEFORMAT_60 );
     204           0 :         if (xStatusIndicator.is())
     205           0 :             xStatusIndicator->setValue(nSteps++);
     206             : 
     207             :         sal_uLong nWarn = ReadThroughComponent(
     208             :             rMedium.GetStorage(), xModelComp, "meta.xml", "Meta.xml",
     209             :             xServiceFactory, xInfoSet,
     210             :                 (bOASIS ? "com.sun.star.comp.Math.XMLOasisMetaImporter"
     211           0 :                         : "com.sun.star.comp.Math.XMLMetaImporter") );
     212             : 
     213           0 :         if ( nWarn != ERRCODE_IO_BROKENPACKAGE )
     214             :         {
     215           0 :             if (xStatusIndicator.is())
     216           0 :                 xStatusIndicator->setValue(nSteps++);
     217             : 
     218             :             nWarn = ReadThroughComponent(
     219             :                 rMedium.GetStorage(), xModelComp, "settings.xml", 0,
     220             :                 xServiceFactory, xInfoSet,
     221             :                 (bOASIS ? "com.sun.star.comp.Math.XMLOasisSettingsImporter"
     222           0 :                         : "com.sun.star.comp.Math.XMLSettingsImporter" ) );
     223             : 
     224           0 :             if ( nWarn != ERRCODE_IO_BROKENPACKAGE )
     225             :             {
     226           0 :                 if (xStatusIndicator.is())
     227           0 :                     xStatusIndicator->setValue(nSteps++);
     228             : 
     229             :                 nError = ReadThroughComponent(
     230             :                     rMedium.GetStorage(), xModelComp, "content.xml", "Content.xml",
     231           0 :                     xServiceFactory, xInfoSet, "com.sun.star.comp.Math.XMLImporter" );
     232             :             }
     233             :             else
     234           0 :                 nError = ERRCODE_IO_BROKENPACKAGE;
     235             :         }
     236             :         else
     237           0 :             nError = ERRCODE_IO_BROKENPACKAGE;
     238             :     }
     239             :     else
     240             :     {
     241             :         Reference<io::XInputStream> xInputStream =
     242           0 :             new utl::OInputStreamWrapper(rMedium.GetInStream());
     243             : 
     244           0 :         if (xStatusIndicator.is())
     245           0 :             xStatusIndicator->setValue(nSteps++);
     246             : 
     247             :         nError = ReadThroughComponent( xInputStream, xModelComp,
     248           0 :             xServiceFactory, xInfoSet, "com.sun.star.comp.Math.XMLImporter", false );
     249             :     }
     250             : 
     251           0 :     if (xStatusIndicator.is())
     252           0 :         xStatusIndicator->end();
     253           0 :     return nError;
     254             : }
     255             : 
     256             : 
     257             : /// read a component (file + filter version)
     258           0 : sal_uLong SmXMLImportWrapper::ReadThroughComponent(
     259             :     Reference<io::XInputStream> xInputStream,
     260             :     Reference<XComponent> xModelComponent,
     261             :     Reference<lang::XMultiServiceFactory> & rFactory,
     262             :     Reference<beans::XPropertySet> & rPropSet,
     263             :     const sal_Char* pFilterName,
     264             :     sal_Bool bEncrypted )
     265             : {
     266           0 :     sal_uLong nError = ERRCODE_SFX_DOLOADFAILED;
     267             :     OSL_ENSURE(xInputStream.is(), "input stream missing");
     268             :     OSL_ENSURE(xModelComponent.is(), "document missing");
     269             :     OSL_ENSURE(rFactory.is(), "factory missing");
     270             :     OSL_ENSURE(NULL != pFilterName,"I need a service name for the component!");
     271             : 
     272             :     // prepare ParserInputSrouce
     273           0 :     xml::sax::InputSource aParserInput;
     274           0 :     aParserInput.aInputStream = xInputStream;
     275             : 
     276             :     // get parser
     277           0 :     Reference< xml::sax::XParser > xParser = xml::sax::Parser::create(comphelper::getComponentContext(rFactory));
     278             : 
     279           0 :     Sequence<Any> aArgs( 1 );
     280           0 :     aArgs[0] <<= rPropSet;
     281             : 
     282             :     // get filter
     283             :     Reference< xml::sax::XDocumentHandler > xFilter(
     284           0 :         rFactory->createInstanceWithArguments(
     285           0 :             OUString::createFromAscii(pFilterName), aArgs ),
     286           0 :         UNO_QUERY );
     287             :     OSL_ENSURE( xFilter.is(), "Can't instantiate filter component." );
     288           0 :     if ( !xFilter.is() )
     289           0 :         return nError;
     290             : 
     291             :     // connect parser and filter
     292           0 :     xParser->setDocumentHandler( xFilter );
     293             : 
     294             :     // connect model and filter
     295           0 :     Reference < XImporter > xImporter( xFilter, UNO_QUERY );
     296           0 :     xImporter->setTargetDocument( xModelComponent );
     297             : 
     298             :     // finally, parser the stream
     299             :     try
     300             :     {
     301           0 :         xParser->parseStream( aParserInput );
     302             : 
     303           0 :         uno::Reference<lang::XUnoTunnel> xFilterTunnel;
     304             :         xFilterTunnel = uno::Reference<lang::XUnoTunnel>
     305           0 :             ( xFilter, uno::UNO_QUERY );
     306             :         SmXMLImport *pFilter = reinterpret_cast< SmXMLImport * >(
     307             :                 sal::static_int_cast< sal_uIntPtr >(
     308           0 :                 xFilterTunnel->getSomething( SmXMLImport::getUnoTunnelId() )));
     309           0 :         if ( pFilter && pFilter->GetSuccess() )
     310           0 :             nError = 0;
     311             :     }
     312           0 :     catch( xml::sax::SAXParseException& r )
     313             :     {
     314             :         // sax parser sends wrapped exceptions,
     315             :         // try to find the original one
     316           0 :         xml::sax::SAXException aSaxEx = *(xml::sax::SAXException*)(&r);
     317           0 :         sal_Bool bTryChild = sal_True;
     318             : 
     319           0 :         while( bTryChild )
     320             :         {
     321           0 :             xml::sax::SAXException aTmp;
     322           0 :             if ( aSaxEx.WrappedException >>= aTmp )
     323           0 :                 aSaxEx = aTmp;
     324             :             else
     325           0 :                 bTryChild = sal_False;
     326           0 :         }
     327             : 
     328           0 :         packages::zip::ZipIOException aBrokenPackage;
     329           0 :         if ( aSaxEx.WrappedException >>= aBrokenPackage )
     330           0 :             return ERRCODE_IO_BROKENPACKAGE;
     331             : 
     332           0 :         if ( bEncrypted )
     333           0 :             nError = ERRCODE_SFX_WRONGPASSWORD;
     334             :     }
     335           0 :     catch( const xml::sax::SAXException& r )
     336             :     {
     337           0 :         packages::zip::ZipIOException aBrokenPackage;
     338           0 :         if ( r.WrappedException >>= aBrokenPackage )
     339           0 :             return ERRCODE_IO_BROKENPACKAGE;
     340             : 
     341           0 :         if ( bEncrypted )
     342           0 :             nError = ERRCODE_SFX_WRONGPASSWORD;
     343             :     }
     344           0 :     catch( packages::zip::ZipIOException& )
     345             :     {
     346           0 :         nError = ERRCODE_IO_BROKENPACKAGE;
     347             :     }
     348           0 :     catch( io::IOException& )
     349             :     {
     350             :     }
     351             : 
     352           0 :     return nError;
     353             : }
     354             : 
     355             : 
     356           0 : sal_uLong SmXMLImportWrapper::ReadThroughComponent(
     357             :     const uno::Reference< embed::XStorage >& xStorage,
     358             :     Reference<XComponent> xModelComponent,
     359             :     const sal_Char* pStreamName,
     360             :     const sal_Char* pCompatibilityStreamName,
     361             :     Reference<lang::XMultiServiceFactory> & rFactory,
     362             :     Reference<beans::XPropertySet> & rPropSet,
     363             :     const sal_Char* pFilterName )
     364             : {
     365             :     OSL_ENSURE(xStorage.is(), "Need storage!");
     366             :     OSL_ENSURE(NULL != pStreamName, "Please, please, give me a name!");
     367             : 
     368             :     // open stream (and set parser input)
     369           0 :     OUString sStreamName = OUString::createFromAscii(pStreamName);
     370           0 :     uno::Reference < container::XNameAccess > xAccess( xStorage, uno::UNO_QUERY );
     371           0 :     if ( !xAccess->hasByName(sStreamName) || !xStorage->isStreamElement(sStreamName) )
     372             :     {
     373             :         // stream name not found! Then try the compatibility name.
     374             :         // do we even have an alternative name?
     375           0 :         if ( pCompatibilityStreamName )
     376           0 :             sStreamName = OUString::createFromAscii(pCompatibilityStreamName);
     377             :     }
     378             : 
     379             :     // get input stream
     380             :     try
     381             :     {
     382           0 :         uno::Reference < io::XStream > xEventsStream = xStorage->openStreamElement( sStreamName, embed::ElementModes::READ );
     383             : 
     384             :         // determine if stream is encrypted or not
     385           0 :         uno::Reference < beans::XPropertySet > xProps( xEventsStream, uno::UNO_QUERY );
     386           0 :         Any aAny = xProps->getPropertyValue( "Encrypted" );
     387           0 :         sal_Bool bEncrypted = sal_False;
     388           0 :         if ( aAny.getValueType() == ::getBooleanCppuType() )
     389           0 :             aAny >>= bEncrypted;
     390             : 
     391             :         // set Base URL
     392           0 :         if ( rPropSet.is() )
     393             :         {
     394           0 :             OUString sPropName( "StreamName");
     395           0 :             rPropSet->setPropertyValue( sPropName, makeAny( sStreamName ) );
     396             :         }
     397             : 
     398             : 
     399           0 :         Reference < io::XInputStream > xStream = xEventsStream->getInputStream();
     400           0 :         return ReadThroughComponent( xStream, xModelComponent, rFactory, rPropSet, pFilterName, bEncrypted );
     401             :     }
     402           0 :     catch ( packages::WrongPasswordException& )
     403             :     {
     404           0 :         return ERRCODE_SFX_WRONGPASSWORD;
     405             :     }
     406           0 :     catch( packages::zip::ZipIOException& )
     407             :     {
     408           0 :         return ERRCODE_IO_BROKENPACKAGE;
     409             :     }
     410           0 :     catch ( uno::Exception& )
     411             :     {
     412             :     }
     413             : 
     414           0 :     return ERRCODE_SFX_DOLOADFAILED;
     415             : }
     416             : 
     417             : ////////////////////////////////////////////////////////////
     418             : 
     419           0 : SmXMLImport::SmXMLImport(
     420             :     const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xServiceFactory,
     421             :     sal_uInt16 nImportFlags)
     422             : :   SvXMLImport( xServiceFactory, nImportFlags ),
     423             :     pPresLayoutElemTokenMap(0),
     424             :     pPresLayoutAttrTokenMap(0),
     425             :     pFencedAttrTokenMap(0),
     426             :     pOperatorAttrTokenMap(0),
     427             :     pAnnotationAttrTokenMap(0),
     428             :     pPresElemTokenMap(0),
     429             :     pPresScriptEmptyElemTokenMap(0),
     430             :     pPresTableElemTokenMap(0),
     431             :     pColorTokenMap(0),
     432           0 :     bSuccess(sal_False)
     433             : {
     434           0 : }
     435             : 
     436             : namespace
     437             : {
     438             :     class theSmXMLImportUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSmXMLImportUnoTunnelId> {};
     439             : }
     440             : 
     441           0 : const uno::Sequence< sal_Int8 > & SmXMLImport::getUnoTunnelId() throw()
     442             : {
     443           0 :     return theSmXMLImportUnoTunnelId::get().getSeq();
     444             : }
     445             : 
     446           9 : OUString SAL_CALL SmXMLImport_getImplementationName() throw()
     447             : {
     448           9 :     return OUString( "com.sun.star.comp.Math.XMLImporter" );
     449             : }
     450             : 
     451           0 : uno::Sequence< OUString > SAL_CALL SmXMLImport_getSupportedServiceNames()
     452             :         throw()
     453             : {
     454           0 :     const OUString aServiceName( IMPORT_SVC_NAME );
     455           0 :     const uno::Sequence< OUString > aSeq( &aServiceName, 1 );
     456           0 :         return aSeq;
     457             : }
     458             : 
     459           0 : uno::Reference< uno::XInterface > SAL_CALL SmXMLImport_createInstance(
     460             :     const uno::Reference< lang::XMultiServiceFactory > & rSMgr)
     461             :     throw( uno::Exception )
     462             : {
     463           0 :     return (cppu::OWeakObject*)new SmXMLImport(rSMgr, IMPORT_ALL);
     464             : }
     465             : 
     466             : ////////////////////////////////////////////////////////////
     467             : 
     468           9 : OUString SAL_CALL SmXMLImportMeta_getImplementationName() throw()
     469             : {
     470           9 :     return OUString( "com.sun.star.comp.Math.XMLOasisMetaImporter" );
     471             : }
     472             : 
     473           0 : uno::Sequence< OUString > SAL_CALL SmXMLImportMeta_getSupportedServiceNames()
     474             : throw()
     475             : {
     476           0 :     const OUString aServiceName( IMPORT_SVC_NAME );
     477           0 :     const uno::Sequence< OUString > aSeq( &aServiceName, 1 );
     478           0 :     return aSeq;
     479             : }
     480             : 
     481           0 : uno::Reference< uno::XInterface > SAL_CALL SmXMLImportMeta_createInstance(
     482             :     const uno::Reference< lang::XMultiServiceFactory > & rSMgr)
     483             : throw( uno::Exception )
     484             : {
     485           0 :     return (cppu::OWeakObject*)new SmXMLImport( rSMgr, IMPORT_META );
     486             : }
     487             : 
     488             : ////////////////////////////////////////////////////////////
     489             : 
     490           9 : OUString SAL_CALL SmXMLImportSettings_getImplementationName() throw()
     491             : {
     492           9 :     return OUString( "com.sun.star.comp.Math.XMLOasisSettingsImporter" );
     493             : }
     494             : 
     495           0 : uno::Sequence< OUString > SAL_CALL SmXMLImportSettings_getSupportedServiceNames()
     496             :         throw()
     497             : {
     498           0 :     const OUString aServiceName( IMPORT_SVC_NAME );
     499           0 :     const uno::Sequence< OUString > aSeq( &aServiceName, 1 );
     500           0 :         return aSeq;
     501             : }
     502             : 
     503           0 : uno::Reference< uno::XInterface > SAL_CALL SmXMLImportSettings_createInstance(
     504             :     const uno::Reference< lang::XMultiServiceFactory > & rSMgr)
     505             :     throw( uno::Exception )
     506             : {
     507           0 :     return (cppu::OWeakObject*)new SmXMLImport( rSMgr, IMPORT_SETTINGS );
     508             : }
     509             : 
     510             : ////////////////////////////////////////////////////////////
     511             : 
     512             : // XServiceInfo
     513             : // override empty method from parent class
     514           0 : rtl::OUString SAL_CALL SmXMLImport::getImplementationName()
     515             :     throw(uno::RuntimeException)
     516             : {
     517           0 :     OUString aTxt;
     518           0 :     switch( getImportFlags() )
     519             :     {
     520             :         case IMPORT_META:
     521           0 :             aTxt = SmXMLImportMeta_getImplementationName();
     522           0 :             break;
     523             :         case IMPORT_SETTINGS:
     524           0 :             aTxt = SmXMLImportSettings_getImplementationName();
     525           0 :             break;
     526             :         case IMPORT_ALL:
     527             :         default:
     528           0 :             aTxt = SmXMLImport_getImplementationName();
     529           0 :             break;
     530             :     }
     531           0 :     return aTxt;
     532             : }
     533             : 
     534             : 
     535           0 : sal_Int64 SAL_CALL SmXMLImport::getSomething(
     536             :     const uno::Sequence< sal_Int8 >&rId )
     537             : throw(uno::RuntimeException)
     538             : {
     539           0 :     if ( rId.getLength() == 16 &&
     540           0 :         0 == memcmp( getUnoTunnelId().getConstArray(),
     541           0 :         rId.getConstArray(), 16 ) )
     542           0 :         return sal::static_int_cast< sal_Int64 >(reinterpret_cast< sal_uIntPtr >(this));
     543             : 
     544           0 :     return SvXMLImport::getSomething( rId );
     545             : }
     546             : 
     547           0 : void SmXMLImport::endDocument(void)
     548             :     throw(xml::sax::SAXException, uno::RuntimeException)
     549             : {
     550             :     //Set the resulted tree into the SmDocShell where it belongs
     551             :     SmNode *pTree;
     552           0 :     if (NULL != (pTree = GetTree()))
     553             :     {
     554           0 :         uno::Reference <frame::XModel> xModel = GetModel();
     555           0 :         uno::Reference <lang::XUnoTunnel> xTunnel;
     556           0 :         xTunnel = uno::Reference <lang::XUnoTunnel> (xModel,uno::UNO_QUERY);
     557             :         SmModel *pModel = reinterpret_cast<SmModel *>
     558           0 :             (xTunnel->getSomething(SmModel::getUnoTunnelId()));
     559             : 
     560           0 :         if (pModel)
     561             :         {
     562             :             SmDocShell *pDocShell =
     563           0 :                 static_cast<SmDocShell*>(pModel->GetObjectShell());
     564           0 :             pDocShell->SetFormulaTree(pTree);
     565           0 :             if (0 == aText.Len())  //If we picked up no annotation text
     566             :             {
     567             :                 //Make up some editable text
     568           0 :                 aText = pDocShell->GetText();
     569           0 :                 pTree->CreateTextFromNode(aText);
     570           0 :                 aText = comphelper::string::stripEnd(aText, ' ');
     571             :             }
     572           0 :             pDocShell->SetText( String() );
     573             : 
     574             :             // Convert symbol names
     575           0 :             SmParser &rParser = pDocShell->GetParser();
     576           0 :             bool bVal = rParser.IsImportSymbolNames();
     577           0 :             rParser.SetImportSymbolNames( true );
     578           0 :             SmNode *pTmpTree = rParser.Parse( aText );
     579           0 :             aText = rParser.GetText();
     580           0 :             delete pTmpTree;
     581           0 :             rParser.SetImportSymbolNames( bVal );
     582             : 
     583           0 :             pDocShell->SetText( aText );
     584             :         }
     585             :         OSL_ENSURE(pModel,"So there *was* a uno problem after all");
     586             : 
     587           0 :         bSuccess = sal_True;
     588             :     }
     589             : 
     590           0 :     SvXMLImport::endDocument();
     591           0 : }
     592             : 
     593             : ////////////////////////////////////////////////////////////
     594             : 
     595           0 : class SmXMLImportContext: public SvXMLImportContext
     596             : {
     597             : public:
     598           0 :     SmXMLImportContext( SmXMLImport &rImport, sal_uInt16 nPrfx,
     599             :         const OUString& rLName)
     600           0 :         : SvXMLImportContext(rImport, nPrfx, rLName) {}
     601             : 
     602             :     const SmXMLImport& GetSmImport() const
     603             :     {
     604             :         return (const SmXMLImport&)GetImport();
     605             :     }
     606             : 
     607           0 :     SmXMLImport& GetSmImport()
     608             :     {
     609           0 :         return (SmXMLImport&)GetImport();
     610             :     }
     611             : 
     612             :     virtual void TCharacters(const OUString & /*rChars*/);
     613             :     virtual void Characters(const OUString &rChars);
     614             :     virtual SvXMLImportContext *CreateChildContext(sal_uInt16 /*nPrefix*/, const OUString& /*rLocalName*/, const uno::Reference< xml::sax::XAttributeList > & /*xAttrList*/);
     615             : };
     616             : 
     617           0 : void SmXMLImportContext::TCharacters(const OUString & /*rChars*/)
     618             : {
     619           0 : }
     620             : 
     621           0 : void SmXMLImportContext::Characters(const OUString &rChars)
     622             : {
     623             :     /*
     624             :     Whitespace occurring within the content of token elements is "trimmed"
     625             :     from the ends (i.e. all whitespace at the beginning and end of the
     626             :     content is removed), and "collapsed" internally (i.e. each sequence of
     627             :     1 or more whitespace characters is replaced with one blank character).
     628             :     */
     629             :     //collapsing not done yet!
     630           0 :     const OUString &rChars2 = rChars.trim();
     631           0 :     if (!rChars2.isEmpty())
     632           0 :         TCharacters(rChars2/*.collapse()*/);
     633           0 : }
     634             : 
     635           0 : SvXMLImportContext * SmXMLImportContext::CreateChildContext(sal_uInt16 /*nPrefix*/,
     636             :     const OUString& /*rLocalName*/,
     637             :     const uno::Reference< xml::sax::XAttributeList > & /*xAttrList*/)
     638             : {
     639           0 :     return 0;
     640             : }
     641             : 
     642             : ////////////////////////////////////////////////////////////
     643             : 
     644           0 : struct SmXMLContext_Helper
     645             : {
     646             :     sal_Int8 nIsBold;
     647             :     sal_Int8 nIsItalic;
     648             :     double nFontSize;
     649             :     sal_Bool bFontNodeNeeded;
     650             :     OUString sFontFamily;
     651             :     OUString sColor;
     652             : 
     653             :     SmXMLImportContext rContext;
     654             : 
     655           0 :     SmXMLContext_Helper(SmXMLImportContext &rImport) :
     656           0 :         nIsBold(-1), nIsItalic(-1), nFontSize(0.0), rContext(rImport)  {}
     657             : 
     658             :     void RetrieveAttrs(const uno::Reference< xml::sax::XAttributeList > &xAttrList );
     659             :     void ApplyAttrs();
     660             : };
     661             : 
     662           0 : void SmXMLContext_Helper::RetrieveAttrs(const uno::Reference<
     663             :     xml::sax::XAttributeList > & xAttrList )
     664             : {
     665           0 :     sal_Int8 nOldIsBold=nIsBold;
     666           0 :     sal_Int8 nOldIsItalic=nIsItalic;
     667           0 :     double nOldFontSize=nFontSize;
     668           0 :     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
     669           0 :     OUString sOldFontFamily = sFontFamily;
     670           0 :     for (sal_Int16 i=0;i<nAttrCount;i++)
     671             :     {
     672           0 :         OUString sAttrName = xAttrList->getNameByIndex(i);
     673           0 :         OUString aLocalName;
     674           0 :         sal_uInt16 nPrefix = rContext.GetSmImport().GetNamespaceMap().
     675           0 :             GetKeyByAttrName(sAttrName,&aLocalName);
     676           0 :         OUString sValue = xAttrList->getValueByIndex(i);
     677             :         const SvXMLTokenMap &rAttrTokenMap =
     678           0 :             rContext.GetSmImport().GetPresLayoutAttrTokenMap();
     679           0 :         switch(rAttrTokenMap.Get(nPrefix,aLocalName))
     680             :         {
     681             :             case XML_TOK_FONTWEIGHT:
     682           0 :                 nIsBold = sValue.equals(GetXMLToken(XML_BOLD));
     683           0 :                 break;
     684             :             case XML_TOK_FONTSTYLE:
     685           0 :                 nIsItalic = sValue.equals(GetXMLToken(XML_ITALIC));
     686           0 :                 break;
     687             :             case XML_TOK_FONTSIZE:
     688           0 :                 ::sax::Converter::convertDouble(nFontSize, sValue);
     689           0 :                 rContext.GetSmImport().GetMM100UnitConverter().
     690           0 :                     SetXMLMeasureUnit(util::MeasureUnit::POINT);
     691           0 :                 if (-1 == sValue.indexOf(GetXMLToken(XML_UNIT_PT)))
     692             :                 {
     693           0 :                     if (-1 == sValue.indexOf('%'))
     694           0 :                         nFontSize=0.0;
     695             :                     else
     696             :                     {
     697           0 :                         rContext.GetSmImport().GetMM100UnitConverter().
     698           0 :                             SetXMLMeasureUnit(util::MeasureUnit::PERCENT);
     699             :                     }
     700             :                 }
     701           0 :                 break;
     702             :             case XML_TOK_FONTFAMILY:
     703           0 :                 sFontFamily = sValue;
     704           0 :                 break;
     705             :             case XML_TOK_COLOR:
     706           0 :                 sColor = sValue;
     707           0 :                 break;
     708             :             default:
     709           0 :                 break;
     710             :         }
     711           0 :     }
     712             : 
     713           0 :     if ((nOldIsBold!=nIsBold) || (nOldIsItalic!=nIsItalic) ||
     714           0 :         (nOldFontSize!=nFontSize) || (sOldFontFamily!=sFontFamily)
     715           0 :         || !sColor.isEmpty())
     716           0 :         bFontNodeNeeded=sal_True;
     717             :     else
     718           0 :         bFontNodeNeeded=sal_False;
     719           0 : }
     720             : 
     721           0 : void SmXMLContext_Helper::ApplyAttrs()
     722             : {
     723           0 :     SmNodeStack &rNodeStack = rContext.GetSmImport().GetNodeStack();
     724             : 
     725           0 :     if (bFontNodeNeeded)
     726             :     {
     727           0 :         SmToken aToken;
     728           0 :         aToken.cMathChar = '\0';
     729           0 :         aToken.nGroup = 0;
     730           0 :         aToken.nLevel = 5;
     731             : 
     732           0 :         if (nIsBold != -1)
     733             :         {
     734           0 :             if (nIsBold)
     735           0 :                 aToken.eType = TBOLD;
     736             :             else
     737           0 :                 aToken.eType = TNBOLD;
     738             :             SmStructureNode *pFontNode = static_cast<SmStructureNode *>
     739           0 :                 (new SmFontNode(aToken));
     740           0 :             pFontNode->SetSubNodes(0,lcl_popOrZero(rNodeStack));
     741           0 :             rNodeStack.push(pFontNode);
     742             :         }
     743           0 :         if (nIsItalic != -1)
     744             :         {
     745           0 :             if (nIsItalic)
     746           0 :                 aToken.eType = TITALIC;
     747             :             else
     748           0 :                 aToken.eType = TNITALIC;
     749             :             SmStructureNode *pFontNode = static_cast<SmStructureNode *>
     750           0 :                 (new SmFontNode(aToken));
     751           0 :             pFontNode->SetSubNodes(0,lcl_popOrZero(rNodeStack));
     752           0 :             rNodeStack.push(pFontNode);
     753             :         }
     754           0 :         if (nFontSize != 0.0)
     755             :         {
     756           0 :             aToken.eType = TSIZE;
     757           0 :             SmFontNode *pFontNode = new SmFontNode(aToken);
     758             : 
     759           0 :             if (util::MeasureUnit::PERCENT == rContext.GetSmImport()
     760           0 :                     .GetMM100UnitConverter().GetXMLMeasureUnit())
     761             :             {
     762           0 :                 if (nFontSize < 100.00)
     763             :                     pFontNode->SetSizeParameter(Fraction(100.00/nFontSize),
     764           0 :                         FNTSIZ_DIVIDE);
     765             :                 else
     766             :                     pFontNode->SetSizeParameter(Fraction(nFontSize/100.00),
     767           0 :                         FNTSIZ_MULTIPLY);
     768             :             }
     769             :             else
     770           0 :                 pFontNode->SetSizeParameter(Fraction(nFontSize),FNTSIZ_ABSOLUT);
     771             : 
     772           0 :             pFontNode->SetSubNodes(0,lcl_popOrZero(rNodeStack));
     773           0 :             rNodeStack.push(pFontNode);
     774             :         }
     775           0 :         if (!sFontFamily.isEmpty())
     776             :         {
     777           0 :             if (sFontFamily.equalsIgnoreAsciiCase(GetXMLToken(XML_FIXED)))
     778           0 :                 aToken.eType = TFIXED;
     779           0 :             else if (sFontFamily.equalsIgnoreAsciiCase("sans"))
     780           0 :                 aToken.eType = TSANS;
     781           0 :             else if (sFontFamily.equalsIgnoreAsciiCase("serif"))
     782           0 :                 aToken.eType = TSERIF;
     783             :             else //Just give up, we need to extend our font mechanism to be
     784             :                 //more general
     785           0 :                 return;
     786             : 
     787           0 :             aToken.aText = sFontFamily;
     788           0 :             SmFontNode *pFontNode = new SmFontNode(aToken);
     789           0 :             pFontNode->SetSubNodes(0,lcl_popOrZero(rNodeStack));
     790           0 :             rNodeStack.push(pFontNode);
     791             :         }
     792           0 :         if (!sColor.isEmpty())
     793             :         {
     794             :             //Again we can only handle a small set of colours in
     795             :             //StarMath for now.
     796             :             const SvXMLTokenMap& rTokenMap =
     797           0 :                 rContext.GetSmImport().GetColorTokenMap();
     798             :             aToken.eType = static_cast<SmTokenType>(rTokenMap.Get(
     799           0 :                 XML_NAMESPACE_MATH, sColor));
     800           0 :             if (aToken.eType != -1)
     801             :             {
     802           0 :                 SmFontNode *pFontNode = new SmFontNode(aToken);
     803           0 :                 pFontNode->SetSubNodes(0,lcl_popOrZero(rNodeStack));
     804           0 :                 rNodeStack.push(pFontNode);
     805             :             }
     806           0 :         }
     807             : 
     808             :     }
     809             : }
     810             : 
     811             : ////////////////////////////////////////////////////////////
     812             : 
     813           0 : class SmXMLDocContext_Impl : public SmXMLImportContext
     814             : {
     815             : public:
     816           0 :     SmXMLDocContext_Impl( SmXMLImport &rImport, sal_uInt16 nPrfx,
     817             :         const OUString& rLName)
     818           0 :         : SmXMLImportContext(rImport,nPrfx,rLName) {}
     819             : 
     820             :     virtual SvXMLImportContext *CreateChildContext(sal_uInt16 nPrefix, const OUString& rLocalName, const uno::Reference< xml::sax::XAttributeList > &xAttrList);
     821             : 
     822             :     void EndElement();
     823             : };
     824             : 
     825             : ////////////////////////////////////////////////////////////
     826             : 
     827             : /*avert thy gaze from the proginator*/
     828           0 : class SmXMLRowContext_Impl : public SmXMLDocContext_Impl
     829             : {
     830             : protected:
     831             :     sal_uLong nElementCount;
     832             : 
     833             : public:
     834           0 :     SmXMLRowContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
     835             :         const OUString& rLName)
     836           0 :         : SmXMLDocContext_Impl(rImport,nPrefix,rLName)
     837           0 :         { nElementCount = GetSmImport().GetNodeStack().size(); }
     838             : 
     839             :     virtual SvXMLImportContext *CreateChildContext(sal_uInt16 nPrefix, const OUString& rLocalName, const uno::Reference< xml::sax::XAttributeList > &xAttrList);
     840             : 
     841             :     SvXMLImportContext *StrictCreateChildContext(sal_uInt16 nPrefix,
     842             :         const OUString& rLocalName,
     843             :         const uno::Reference< xml::sax::XAttributeList > &xAttrList);
     844             : 
     845             :     void EndElement();
     846             : };
     847             : 
     848             : ////////////////////////////////////////////////////////////
     849             : 
     850           0 : class SmXMLFracContext_Impl : public SmXMLRowContext_Impl
     851             : {
     852             : public:
     853           0 :     SmXMLFracContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
     854             :         const OUString& rLName)
     855           0 :         : SmXMLRowContext_Impl(rImport,nPrefix,rLName) {}
     856             : 
     857             :     void EndElement();
     858             : };
     859             : 
     860             : ////////////////////////////////////////////////////////////
     861             : 
     862           0 : class SmXMLSqrtContext_Impl : public SmXMLRowContext_Impl
     863             : {
     864             : public:
     865           0 :     SmXMLSqrtContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
     866             :         const OUString& rLName)
     867           0 :         : SmXMLRowContext_Impl(rImport,nPrefix,rLName) {}
     868             : 
     869             :     void EndElement();
     870             : };
     871             : 
     872             : ////////////////////////////////////////////////////////////
     873             : 
     874           0 : class SmXMLRootContext_Impl : public SmXMLRowContext_Impl
     875             : {
     876             : public:
     877           0 :     SmXMLRootContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
     878             :         const OUString& rLName)
     879           0 :         : SmXMLRowContext_Impl(rImport,nPrefix,rLName) {}
     880             : 
     881             :     void EndElement();
     882             : };
     883             : 
     884             : ////////////////////////////////////////////////////////////
     885             : 
     886           0 : class SmXMLStyleContext_Impl : public SmXMLRowContext_Impl
     887             : {
     888             : protected:
     889             :     SmXMLContext_Helper aStyleHelper;
     890             : 
     891             : public:
     892             :     /*Right now the style tag is completely ignored*/
     893           0 :     SmXMLStyleContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
     894             :         const OUString& rLName) : SmXMLRowContext_Impl(rImport,nPrefix,rLName),
     895           0 :         aStyleHelper(*this) {}
     896             : 
     897             :     void EndElement();
     898             :     void StartElement(const uno::Reference< xml::sax::XAttributeList > &xAttrList );
     899             : };
     900             : 
     901           0 : void SmXMLStyleContext_Impl::StartElement(const uno::Reference<
     902             :     xml::sax::XAttributeList > & xAttrList )
     903             : {
     904           0 :     aStyleHelper.RetrieveAttrs(xAttrList);
     905           0 : }
     906             : 
     907             : 
     908           0 : void SmXMLStyleContext_Impl::EndElement()
     909             : {
     910             :     /*
     911             :     <mstyle> accepts any number of arguments; if this number is not 1, its
     912             :     contents are treated as a single "inferred <mrow>" containing its
     913             :     arguments
     914             :     */
     915           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
     916           0 :     if (rNodeStack.size() - nElementCount > 1)
     917           0 :         SmXMLRowContext_Impl::EndElement();
     918           0 :     aStyleHelper.ApplyAttrs();
     919           0 : }
     920             : 
     921             : ////////////////////////////////////////////////////////////
     922             : 
     923           0 : class SmXMLPaddedContext_Impl : public SmXMLRowContext_Impl
     924             : {
     925             : public:
     926             :     /*Right now the style tag is completely ignored*/
     927           0 :     SmXMLPaddedContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
     928             :         const OUString& rLName)
     929           0 :         : SmXMLRowContext_Impl(rImport,nPrefix,rLName) {}
     930             : 
     931             :     void EndElement();
     932             : };
     933             : 
     934           0 : void SmXMLPaddedContext_Impl::EndElement()
     935             : {
     936             :     /*
     937             :     <mpadded> accepts any number of arguments; if this number is not 1, its
     938             :     contents are treated as a single "inferred <mrow>" containing its
     939             :     arguments
     940             :     */
     941           0 :     if (GetSmImport().GetNodeStack().size() - nElementCount > 1)
     942           0 :         SmXMLRowContext_Impl::EndElement();
     943           0 : }
     944             : 
     945             : ////////////////////////////////////////////////////////////
     946             : 
     947           0 : class SmXMLPhantomContext_Impl : public SmXMLRowContext_Impl
     948             : {
     949             : public:
     950             :     /*Right now the style tag is completely ignored*/
     951           0 :     SmXMLPhantomContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
     952             :         const OUString& rLName)
     953           0 :         : SmXMLRowContext_Impl(rImport,nPrefix,rLName) {}
     954             : 
     955             :     void EndElement();
     956             : };
     957             : 
     958           0 : void SmXMLPhantomContext_Impl::EndElement()
     959             : {
     960             :     /*
     961             :     <mphantom> accepts any number of arguments; if this number is not 1, its
     962             :     contents are treated as a single "inferred <mrow>" containing its
     963             :     arguments
     964             :     */
     965           0 :     if (GetSmImport().GetNodeStack().size() - nElementCount > 1)
     966           0 :         SmXMLRowContext_Impl::EndElement();
     967             : 
     968           0 :     SmToken aToken;
     969           0 :     aToken.cMathChar = '\0';
     970           0 :     aToken.nGroup = 0;
     971           0 :     aToken.nLevel = 5;
     972           0 :     aToken.eType = TPHANTOM;
     973             : 
     974             :     SmStructureNode *pPhantom = static_cast<SmStructureNode *>
     975           0 :         (new SmFontNode(aToken));
     976           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
     977           0 :     pPhantom->SetSubNodes(0,lcl_popOrZero(rNodeStack));
     978           0 :     rNodeStack.push(pPhantom);
     979           0 : }
     980             : 
     981             : ////////////////////////////////////////////////////////////
     982             : 
     983           0 : class SmXMLFencedContext_Impl : public SmXMLRowContext_Impl
     984             : {
     985             : protected:
     986             :     sal_Unicode cBegin;
     987             :     sal_Unicode cEnd;
     988             : 
     989             : public:
     990           0 :     SmXMLFencedContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
     991             :         const OUString& rLName)
     992             :         : SmXMLRowContext_Impl(rImport,nPrefix,rLName),
     993           0 :         cBegin('('), cEnd(')') {}
     994             : 
     995             :     void StartElement(const uno::Reference< xml::sax::XAttributeList > & xAttrList );
     996             :     void EndElement();
     997             : };
     998             : 
     999             : 
    1000           0 : void SmXMLFencedContext_Impl::StartElement(const uno::Reference<
    1001             :     xml::sax::XAttributeList > & xAttrList )
    1002             : {
    1003           0 :     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
    1004           0 :     for (sal_Int16 i=0;i<nAttrCount;i++)
    1005             :     {
    1006           0 :         OUString sAttrName = xAttrList->getNameByIndex(i);
    1007           0 :         OUString aLocalName;
    1008           0 :         sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
    1009           0 :             GetKeyByAttrName(sAttrName,&aLocalName);
    1010           0 :         OUString sValue = xAttrList->getValueByIndex(i);
    1011             :         const SvXMLTokenMap &rAttrTokenMap =
    1012           0 :             GetSmImport().GetFencedAttrTokenMap();
    1013           0 :         switch(rAttrTokenMap.Get(nPrefix,aLocalName))
    1014             :         {
    1015             :             //temp, starmath cannot handle multichar brackets (I think)
    1016             :             case XML_TOK_OPEN:
    1017           0 :                 cBegin = sValue[0];
    1018           0 :                 break;
    1019             :             case XML_TOK_CLOSE:
    1020           0 :                 cEnd = sValue[0];
    1021           0 :                 break;
    1022             :             default:
    1023             :                 /*Go to superclass*/
    1024           0 :                 break;
    1025             :         }
    1026           0 :     }
    1027           0 : }
    1028             : 
    1029             : 
    1030           0 : void SmXMLFencedContext_Impl::EndElement()
    1031             : {
    1032           0 :     SmToken aToken;
    1033           0 :     aToken.cMathChar = '\0';
    1034           0 :     aToken.nGroup = 0;
    1035           0 :     aToken.aText = ",";
    1036           0 :     aToken.eType = TLEFT;
    1037           0 :     aToken.nLevel = 5;
    1038             : 
    1039           0 :     aToken.eType = TLPARENT;
    1040           0 :     aToken.cMathChar = cBegin;
    1041           0 :     SmStructureNode *pSNode = new SmBraceNode(aToken);
    1042           0 :     SmNode *pLeft = new SmMathSymbolNode(aToken);
    1043             : 
    1044           0 :     aToken.cMathChar = cEnd;
    1045           0 :     aToken.eType = TRPARENT;
    1046           0 :     SmNode *pRight = new SmMathSymbolNode(aToken);
    1047             : 
    1048           0 :     SmNodeArray aRelationArray;
    1049           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
    1050             : 
    1051           0 :     aToken.cMathChar = '\0';
    1052           0 :     aToken.aText = ",";
    1053           0 :     aToken.eType = TIDENT;
    1054             : 
    1055           0 :     sal_uLong i = rNodeStack.size() - nElementCount;
    1056           0 :     if (rNodeStack.size() - nElementCount > 1)
    1057           0 :         i += rNodeStack.size() - 1 - nElementCount;
    1058           0 :     aRelationArray.resize(i);
    1059           0 :     while (rNodeStack.size() > nElementCount)
    1060             :     {
    1061           0 :         aRelationArray[--i] = rNodeStack.top();
    1062           0 :         rNodeStack.pop();
    1063           0 :         if (i > 1 && rNodeStack.size() > 1)
    1064           0 :             aRelationArray[--i] = new SmGlyphSpecialNode(aToken);
    1065             :     }
    1066             : 
    1067           0 :     SmToken aDummy;
    1068           0 :     SmStructureNode *pBody = new SmExpressionNode(aDummy);
    1069           0 :     pBody->SetSubNodes(aRelationArray);
    1070             : 
    1071             : 
    1072           0 :     pSNode->SetSubNodes(pLeft,pBody,pRight);
    1073           0 :     pSNode->SetScaleMode(SCALE_HEIGHT);
    1074           0 :     GetSmImport().GetNodeStack().push(pSNode);
    1075           0 : }
    1076             : 
    1077             : 
    1078             : ////////////////////////////////////////////////////////////
    1079             : 
    1080           0 : class SmXMLErrorContext_Impl : public SmXMLRowContext_Impl
    1081             : {
    1082             : public:
    1083           0 :     SmXMLErrorContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1084             :         const OUString& rLName)
    1085           0 :         : SmXMLRowContext_Impl(rImport,nPrefix,rLName) {}
    1086             : 
    1087             :     void EndElement();
    1088             : };
    1089             : 
    1090           0 : void SmXMLErrorContext_Impl::EndElement()
    1091             : {
    1092             :     /*Right now the error tag is completely ignored, what
    1093             :      can I do with it in starmath, ?, maybe we need a
    1094             :      report window ourselves, do a test for validity of
    1095             :      the xml input, use merrors, and then generate
    1096             :      the markup inside the merror with a big red colour
    1097             :      of something. For now just throw them all away.
    1098             :      */
    1099           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
    1100           0 :     while (rNodeStack.size() > nElementCount)
    1101             :     {
    1102           0 :         delete rNodeStack.top();
    1103           0 :         rNodeStack.pop();
    1104             :     }
    1105           0 : }
    1106             : 
    1107             : ////////////////////////////////////////////////////////////
    1108             : 
    1109           0 : class SmXMLNumberContext_Impl : public SmXMLImportContext
    1110             : {
    1111             : protected:
    1112             :     SmToken aToken;
    1113             : 
    1114             : public:
    1115           0 :     SmXMLNumberContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1116             :         const OUString& rLName)
    1117           0 :         : SmXMLImportContext(rImport,nPrefix,rLName)
    1118             :     {
    1119           0 :         aToken.cMathChar = '\0';
    1120           0 :         aToken.nGroup = 0;
    1121           0 :         aToken.nLevel = 5;
    1122           0 :         aToken.eType = TNUMBER;
    1123           0 :     }
    1124             : 
    1125             :     virtual void TCharacters(const OUString &rChars);
    1126             : 
    1127             :     void EndElement();
    1128             : };
    1129             : 
    1130           0 : void SmXMLNumberContext_Impl::TCharacters(const OUString &rChars)
    1131             : {
    1132           0 :     aToken.aText = rChars;
    1133           0 : }
    1134             : 
    1135           0 : void SmXMLNumberContext_Impl::EndElement()
    1136             : {
    1137           0 :     GetSmImport().GetNodeStack().push(new SmTextNode(aToken,FNT_NUMBER));
    1138           0 : }
    1139             : 
    1140             : ////////////////////////////////////////////////////////////
    1141             : 
    1142           0 : class SmXMLAnnotationContext_Impl : public SmXMLImportContext
    1143             : {
    1144             :     sal_Bool bIsStarMath;
    1145             : 
    1146             : public:
    1147           0 :     SmXMLAnnotationContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1148             :         const OUString& rLName)
    1149           0 :         : SmXMLImportContext(rImport,nPrefix,rLName), bIsStarMath(sal_False) {}
    1150             : 
    1151             :     virtual void Characters(const OUString &rChars);
    1152             : 
    1153             :     void StartElement(const uno::Reference<xml::sax::XAttributeList > & xAttrList );
    1154             : };
    1155             : 
    1156           0 : void SmXMLAnnotationContext_Impl::StartElement(const uno::Reference<
    1157             :     xml::sax::XAttributeList > & xAttrList )
    1158             : {
    1159           0 :     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
    1160           0 :     for (sal_Int16 i=0;i<nAttrCount;i++)
    1161             :     {
    1162           0 :         OUString sAttrName = xAttrList->getNameByIndex(i);
    1163           0 :         OUString aLocalName;
    1164           0 :         sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
    1165           0 :             GetKeyByAttrName(sAttrName,&aLocalName);
    1166             : 
    1167           0 :         OUString sValue = xAttrList->getValueByIndex(i);
    1168             :         const SvXMLTokenMap &rAttrTokenMap =
    1169           0 :             GetSmImport().GetAnnotationAttrTokenMap();
    1170           0 :         switch(rAttrTokenMap.Get(nPrefix,aLocalName))
    1171             :         {
    1172             :             case XML_TOK_ENCODING:
    1173           0 :                 bIsStarMath= sValue == "StarMath 5.0";
    1174           0 :                 break;
    1175             :             default:
    1176           0 :                 break;
    1177             :         }
    1178           0 :     }
    1179           0 : }
    1180             : 
    1181           0 : void SmXMLAnnotationContext_Impl::Characters(const OUString &rChars)
    1182             : {
    1183           0 :     if (bIsStarMath)
    1184           0 :         GetSmImport().GetText().Append(String(rChars));
    1185           0 : }
    1186             : 
    1187             : ////////////////////////////////////////////////////////////
    1188             : 
    1189           0 : class SmXMLTextContext_Impl : public SmXMLImportContext
    1190             : {
    1191             : protected:
    1192             :     SmToken aToken;
    1193             : 
    1194             : public:
    1195           0 :     SmXMLTextContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1196             :         const OUString& rLName)
    1197           0 :         : SmXMLImportContext(rImport,nPrefix,rLName)
    1198             :     {
    1199           0 :         aToken.cMathChar = '\0';
    1200           0 :         aToken.nGroup = 0;
    1201           0 :         aToken.nLevel = 5;
    1202           0 :         aToken.eType = TTEXT;
    1203           0 :     }
    1204             : 
    1205             :     virtual void TCharacters(const OUString &rChars);
    1206             : 
    1207             :     void EndElement();
    1208             : };
    1209             : 
    1210           0 : void SmXMLTextContext_Impl::TCharacters(const OUString &rChars)
    1211             : {
    1212           0 :     aToken.aText = rChars;
    1213           0 : }
    1214             : 
    1215           0 : void SmXMLTextContext_Impl::EndElement()
    1216             : {
    1217           0 :     GetSmImport().GetNodeStack().push(new SmTextNode(aToken,FNT_TEXT));
    1218           0 : }
    1219             : 
    1220             : ////////////////////////////////////////////////////////////
    1221             : 
    1222           0 : class SmXMLStringContext_Impl : public SmXMLImportContext
    1223             : {
    1224             : protected:
    1225             :     SmToken aToken;
    1226             : 
    1227             : public:
    1228           0 :     SmXMLStringContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1229             :         const OUString& rLName)
    1230           0 :         : SmXMLImportContext(rImport,nPrefix,rLName)
    1231             :     {
    1232           0 :         aToken.cMathChar = '\0';
    1233           0 :         aToken.nGroup = 0;
    1234           0 :         aToken.nLevel = 5;
    1235           0 :         aToken.eType = TTEXT;
    1236           0 :     }
    1237             : 
    1238             :     virtual void TCharacters(const OUString &rChars);
    1239             : 
    1240             :     void EndElement();
    1241             : };
    1242             : 
    1243           0 : void SmXMLStringContext_Impl::TCharacters(const OUString &rChars)
    1244             : {
    1245             :     /*
    1246             :     The content of <ms> elements should be rendered with visible "escaping" of
    1247             :     certain characters in the content, including at least "double quote"
    1248             :     itself, and preferably whitespace other than individual blanks. The intent
    1249             :     is for the viewer to see that the expression is a string literal, and to
    1250             :     see exactly which characters form its content. For example, <ms>double
    1251             :     quote is "</ms> might be rendered as "double quote is \"".
    1252             : 
    1253             :     Obviously this isn't fully done here.
    1254             :     */
    1255           0 :     aToken.aText = "\"" + rChars + "\"";
    1256           0 : }
    1257             : 
    1258           0 : void SmXMLStringContext_Impl::EndElement()
    1259             : {
    1260           0 :     GetSmImport().GetNodeStack().push(new SmTextNode(aToken,FNT_FIXED));
    1261           0 : }
    1262             : 
    1263             : ////////////////////////////////////////////////////////////
    1264             : 
    1265           0 : class SmXMLIdentifierContext_Impl : public SmXMLImportContext
    1266             : {
    1267             : protected:
    1268             :     SmXMLContext_Helper aStyleHelper;
    1269             :     SmToken aToken;
    1270             : 
    1271             : public:
    1272           0 :     SmXMLIdentifierContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1273             :         const OUString& rLName)
    1274           0 :         : SmXMLImportContext(rImport,nPrefix,rLName),aStyleHelper(*this)
    1275             :     {
    1276           0 :         aToken.cMathChar = '\0';
    1277           0 :         aToken.nGroup = 0;
    1278           0 :         aToken.nLevel = 5;
    1279           0 :         aToken.eType = TIDENT;
    1280           0 :     }
    1281             : 
    1282             :     void TCharacters(const OUString &rChars);
    1283           0 :     void StartElement(const uno::Reference< xml::sax::XAttributeList > & xAttrList )
    1284             :     {
    1285           0 :         aStyleHelper.RetrieveAttrs(xAttrList);
    1286           0 :     };
    1287             :     void EndElement();
    1288             : };
    1289             : 
    1290           0 : void SmXMLIdentifierContext_Impl::EndElement()
    1291             : {
    1292           0 :     SmTextNode *pNode = 0;
    1293             :     //we will handle identifier italic/normal here instead of with a standalone
    1294             :     //font node
    1295           0 :     if (((aStyleHelper.nIsItalic == -1) && (aToken.aText.getLength() > 1))
    1296           0 :         || ((aStyleHelper.nIsItalic == 0) && (aToken.aText.getLength() == 1)))
    1297             :     {
    1298           0 :         pNode = new SmTextNode(aToken,FNT_FUNCTION);
    1299           0 :         pNode->GetFont().SetItalic(ITALIC_NONE);
    1300           0 :         aStyleHelper.nIsItalic = -1;
    1301             :     }
    1302             :     else
    1303           0 :         pNode = new SmTextNode(aToken,FNT_VARIABLE);
    1304           0 :     if (aStyleHelper.bFontNodeNeeded && aStyleHelper.nIsItalic != -1)
    1305             :     {
    1306           0 :         if (aStyleHelper.nIsItalic)
    1307           0 :             pNode->GetFont().SetItalic(ITALIC_NORMAL);
    1308             :         else
    1309           0 :             pNode->GetFont().SetItalic(ITALIC_NONE);
    1310             :     }
    1311             : 
    1312           0 :     if ((-1!=aStyleHelper.nIsBold) || (0.0!=aStyleHelper.nFontSize) ||
    1313           0 :         (!aStyleHelper.sFontFamily.isEmpty()) ||
    1314           0 :         !aStyleHelper.sColor.isEmpty())
    1315           0 :         aStyleHelper.bFontNodeNeeded=sal_True;
    1316             :     else
    1317           0 :         aStyleHelper.bFontNodeNeeded=sal_False;
    1318           0 :     if (aStyleHelper.bFontNodeNeeded)
    1319           0 :         aStyleHelper.ApplyAttrs();
    1320           0 :     GetSmImport().GetNodeStack().push(pNode);
    1321           0 : }
    1322             : 
    1323           0 : void SmXMLIdentifierContext_Impl::TCharacters(const OUString &rChars)
    1324             : {
    1325           0 :     aToken.aText = rChars;
    1326           0 : }
    1327             : 
    1328             : ////////////////////////////////////////////////////////////
    1329             : 
    1330           0 : class SmXMLOperatorContext_Impl : public SmXMLImportContext
    1331             : {
    1332             :     sal_Bool bIsStretchy;
    1333             : 
    1334             : protected:
    1335             :     SmToken aToken;
    1336             : 
    1337             : public:
    1338           0 :     SmXMLOperatorContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1339             :         const OUString& rLName)
    1340           0 :         : SmXMLImportContext(rImport,nPrefix,rLName), bIsStretchy(sal_False)
    1341             :     {
    1342           0 :         aToken.nGroup = 0;
    1343           0 :         aToken.eType = TSPECIAL;
    1344           0 :         aToken.nLevel = 5;
    1345           0 :     }
    1346             : 
    1347             :     void TCharacters(const OUString &rChars);
    1348             :     void StartElement(const uno::Reference< xml::sax::XAttributeList > &xAttrList );
    1349             :     void EndElement();
    1350             : };
    1351             : 
    1352           0 : void SmXMLOperatorContext_Impl::TCharacters(const OUString &rChars)
    1353             : {
    1354           0 :     aToken.cMathChar = rChars[0];
    1355           0 : }
    1356             : 
    1357           0 : void SmXMLOperatorContext_Impl::EndElement()
    1358             : {
    1359           0 :     SmMathSymbolNode *pNode = new SmMathSymbolNode(aToken);
    1360             :     //For stretchy scaling the scaling must be retrieved from this node
    1361             :     //and applied to the expression itself so as to get the expression
    1362             :     //to scale the operator to the height of the expression itself
    1363           0 :     if (bIsStretchy)
    1364           0 :         pNode->SetScaleMode(SCALE_HEIGHT);
    1365           0 :     GetSmImport().GetNodeStack().push(pNode);
    1366           0 : }
    1367             : 
    1368             : 
    1369             : 
    1370           0 : void SmXMLOperatorContext_Impl::StartElement(const uno::Reference<
    1371             :     xml::sax::XAttributeList > & xAttrList )
    1372             : {
    1373           0 :     sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
    1374           0 :     for (sal_Int16 i=0;i<nAttrCount;i++)
    1375             :     {
    1376           0 :         OUString sAttrName = xAttrList->getNameByIndex(i);
    1377           0 :         OUString aLocalName;
    1378           0 :         sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
    1379           0 :             GetKeyByAttrName(sAttrName,&aLocalName);
    1380             : 
    1381           0 :         OUString sValue = xAttrList->getValueByIndex(i);
    1382             :         const SvXMLTokenMap &rAttrTokenMap =
    1383           0 :             GetSmImport().GetOperatorAttrTokenMap();
    1384           0 :         switch(rAttrTokenMap.Get(nPrefix,aLocalName))
    1385             :         {
    1386             :             case XML_TOK_STRETCHY:
    1387             :                 bIsStretchy = sValue.equals(
    1388           0 :                     GetXMLToken(XML_TRUE));
    1389           0 :                 break;
    1390             :             default:
    1391           0 :                 break;
    1392             :         }
    1393           0 :     }
    1394           0 : }
    1395             : 
    1396             : 
    1397             : ////////////////////////////////////////////////////////////
    1398             : 
    1399           0 : class SmXMLSpaceContext_Impl : public SmXMLImportContext
    1400             : {
    1401             : public:
    1402           0 :     SmXMLSpaceContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1403             :         const OUString& rLName)
    1404           0 :         : SmXMLImportContext(rImport,nPrefix,rLName) {}
    1405             : 
    1406             :     void StartElement(const uno::Reference< xml::sax::XAttributeList >& xAttrList );
    1407             : };
    1408             : 
    1409           0 : void SmXMLSpaceContext_Impl::StartElement(
    1410             :     const uno::Reference<xml::sax::XAttributeList > & /*xAttrList*/ )
    1411             : {
    1412           0 :     SmToken aToken;
    1413           0 :     aToken.cMathChar = '\0';
    1414           0 :     aToken.nGroup = 0;
    1415           0 :     aToken.eType = TBLANK;
    1416           0 :     aToken.nLevel = 5;
    1417           0 :     SmBlankNode *pBlank = new SmBlankNode(aToken);
    1418           0 :     pBlank->IncreaseBy(aToken);
    1419           0 :     GetSmImport().GetNodeStack().push(pBlank);
    1420           0 : }
    1421             : 
    1422             : ////////////////////////////////////////////////////////////
    1423             : 
    1424           0 : class SmXMLSubContext_Impl : public SmXMLRowContext_Impl
    1425             : {
    1426             : protected:
    1427             :     void GenericEndElement(SmTokenType eType,SmSubSup aSubSup);
    1428             : 
    1429             : public:
    1430           0 :     SmXMLSubContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1431             :         const OUString& rLName)
    1432           0 :         : SmXMLRowContext_Impl(rImport,nPrefix,rLName) {}
    1433             : 
    1434           0 :     void EndElement()
    1435             :     {
    1436           0 :         GenericEndElement(TRSUB,RSUB);
    1437           0 :     }
    1438             : };
    1439             : 
    1440             : 
    1441           0 : void SmXMLSubContext_Impl::GenericEndElement(SmTokenType eType, SmSubSup eSubSup)
    1442             : {
    1443             :     /*The <msub> element requires exactly 2 arguments.*/
    1444           0 :     const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 2;
    1445             :     OSL_ENSURE( bNodeCheck, "Sub has not two arguments" );
    1446           0 :     if (!bNodeCheck)
    1447           0 :         return;
    1448             : 
    1449           0 :     SmToken aToken;
    1450           0 :     aToken.cMathChar = '\0';
    1451           0 :     aToken.nGroup = 0;
    1452           0 :     aToken.nLevel = 0;
    1453           0 :     aToken.eType = eType;
    1454           0 :     SmSubSupNode *pNode = new SmSubSupNode(aToken);
    1455           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
    1456             : 
    1457             :     // initialize subnodes array
    1458           0 :     SmNodeArray  aSubNodes;
    1459           0 :     aSubNodes.resize(1 + SUBSUP_NUM_ENTRIES);
    1460           0 :     for (sal_uLong i = 1;  i < aSubNodes.size();  i++)
    1461           0 :         aSubNodes[i] = NULL;
    1462             : 
    1463           0 :     aSubNodes[eSubSup+1] = lcl_popOrZero(rNodeStack);
    1464           0 :     aSubNodes[0] = lcl_popOrZero(rNodeStack);
    1465           0 :     pNode->SetSubNodes(aSubNodes);
    1466           0 :     rNodeStack.push(pNode);
    1467             : }
    1468             : 
    1469             : ////////////////////////////////////////////////////////////
    1470             : 
    1471           0 : class SmXMLSupContext_Impl : public SmXMLSubContext_Impl
    1472             : {
    1473             : public:
    1474           0 :     SmXMLSupContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1475             :         const OUString& rLName)
    1476           0 :         : SmXMLSubContext_Impl(rImport,nPrefix,rLName) {}
    1477             : 
    1478           0 :     void EndElement()
    1479             :     {
    1480           0 :         GenericEndElement(TRSUP,RSUP);
    1481           0 :     }
    1482             : };
    1483             : 
    1484             : ////////////////////////////////////////////////////////////
    1485             : 
    1486           0 : class SmXMLSubSupContext_Impl : public SmXMLRowContext_Impl
    1487             : {
    1488             : protected:
    1489             :     void GenericEndElement(SmTokenType eType, SmSubSup aSub,SmSubSup aSup);
    1490             : 
    1491             : public:
    1492           0 :     SmXMLSubSupContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1493             :         const OUString& rLName)
    1494           0 :         : SmXMLRowContext_Impl(rImport,nPrefix,rLName) {}
    1495             : 
    1496           0 :     void EndElement()
    1497             :     {
    1498           0 :         GenericEndElement(TRSUB,RSUB,RSUP);
    1499           0 :     }
    1500             : };
    1501             : 
    1502           0 : void SmXMLSubSupContext_Impl::GenericEndElement(SmTokenType eType,
    1503             :         SmSubSup aSub,SmSubSup aSup)
    1504             : {
    1505             :     /*The <msub> element requires exactly 3 arguments.*/
    1506           0 :     const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 3;
    1507             :     OSL_ENSURE( bNodeCheck, "SubSup has not three arguments" );
    1508           0 :     if (!bNodeCheck)
    1509           0 :         return;
    1510             : 
    1511           0 :     SmToken aToken;
    1512           0 :     aToken.cMathChar = '\0';
    1513           0 :     aToken.nGroup = 0;
    1514           0 :     aToken.nLevel = 0;
    1515           0 :     aToken.eType = eType;
    1516           0 :     SmSubSupNode *pNode = new SmSubSupNode(aToken);
    1517           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
    1518             : 
    1519             :     // initialize subnodes array
    1520           0 :     SmNodeArray  aSubNodes;
    1521           0 :     aSubNodes.resize(1 + SUBSUP_NUM_ENTRIES);
    1522           0 :     for (sal_uLong i = 1;  i < aSubNodes.size();  i++)
    1523           0 :         aSubNodes[i] = NULL;
    1524             : 
    1525           0 :     aSubNodes[aSup+1] = lcl_popOrZero(rNodeStack);
    1526           0 :     aSubNodes[aSub+1] = lcl_popOrZero(rNodeStack);
    1527           0 :     aSubNodes[0] =  lcl_popOrZero(rNodeStack);
    1528           0 :     pNode->SetSubNodes(aSubNodes);
    1529           0 :     rNodeStack.push(pNode);
    1530             : }
    1531             : 
    1532             : ////////////////////////////////////////////////////////////
    1533             : 
    1534           0 : class SmXMLUnderContext_Impl : public SmXMLSubContext_Impl
    1535             : {
    1536             : protected:
    1537             :     sal_Int16 nAttrCount;
    1538             : 
    1539             : public:
    1540           0 :     SmXMLUnderContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1541             :         const OUString& rLName)
    1542           0 :         : SmXMLSubContext_Impl(rImport,nPrefix,rLName) {}
    1543             : 
    1544             :     void StartElement(const uno::Reference< xml::sax::XAttributeList > &xAttrList );
    1545             :     void EndElement();
    1546             :     void HandleAccent();
    1547             : };
    1548             : 
    1549           0 : void SmXMLUnderContext_Impl::StartElement(const uno::Reference<
    1550             :     xml::sax::XAttributeList > & xAttrList )
    1551             : {
    1552           0 :     nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
    1553           0 : }
    1554             : 
    1555           0 : void SmXMLUnderContext_Impl::HandleAccent()
    1556             : {
    1557           0 :     const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 2;
    1558             :     OSL_ENSURE( bNodeCheck, "Sub has not two arguments" );
    1559           0 :     if (!bNodeCheck)
    1560           0 :         return;
    1561             : 
    1562             :     /*Just one special case for the underline thing*/
    1563           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
    1564           0 :     SmNode *pTest = lcl_popOrZero(rNodeStack);
    1565           0 :     SmToken aToken;
    1566           0 :     aToken.cMathChar = '\0';
    1567           0 :     aToken.nGroup = 0;
    1568           0 :     aToken.nLevel = 0;
    1569           0 :     aToken.eType = TUNDERLINE;
    1570             : 
    1571             : 
    1572           0 :     SmNodeArray aSubNodes;
    1573           0 :     aSubNodes.resize(2);
    1574             : 
    1575           0 :     SmStructureNode *pNode = new SmAttributNode(aToken);
    1576           0 :     if ((pTest->GetToken().cMathChar & 0x0FFF) == 0x0332)
    1577             :     {
    1578           0 :         aSubNodes[0] = new SmRectangleNode(aToken);
    1579           0 :         delete pTest;
    1580             :     }
    1581             :     else
    1582           0 :         aSubNodes[0] = pTest;
    1583             : 
    1584           0 :     aSubNodes[1] = lcl_popOrZero(rNodeStack);
    1585           0 :     pNode->SetSubNodes(aSubNodes);
    1586           0 :     pNode->SetScaleMode(SCALE_WIDTH);
    1587           0 :     rNodeStack.push(pNode);
    1588             : }
    1589             : 
    1590             : 
    1591           0 : void SmXMLUnderContext_Impl::EndElement()
    1592             : {
    1593           0 :     if (!nAttrCount)
    1594           0 :         GenericEndElement(TCSUB,CSUB);
    1595             :     else
    1596           0 :         HandleAccent();
    1597           0 : }
    1598             : 
    1599             : ////////////////////////////////////////////////////////////
    1600             : 
    1601           0 : class SmXMLOverContext_Impl : public SmXMLSubContext_Impl
    1602             : {
    1603             : protected:
    1604             :     sal_Int16 nAttrCount;
    1605             : 
    1606             : public:
    1607           0 :     SmXMLOverContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1608             :         const OUString& rLName)
    1609           0 :         : SmXMLSubContext_Impl(rImport,nPrefix,rLName), nAttrCount(0) {}
    1610             : 
    1611             :     void EndElement();
    1612             :     void StartElement(const uno::Reference< xml::sax::XAttributeList > &xAttrList );
    1613             :     void HandleAccent();
    1614             : };
    1615             : 
    1616             : 
    1617           0 : void SmXMLOverContext_Impl::StartElement(const uno::Reference<
    1618             :     xml::sax::XAttributeList > & xAttrList )
    1619             : {
    1620           0 :     nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
    1621           0 : }
    1622             : 
    1623             : 
    1624           0 : void SmXMLOverContext_Impl::EndElement()
    1625             : {
    1626           0 :     if (!nAttrCount)
    1627           0 :         GenericEndElement(TCSUP,CSUP);
    1628             :     else
    1629           0 :         HandleAccent();
    1630           0 : }
    1631             : 
    1632             : 
    1633           0 : void SmXMLOverContext_Impl::HandleAccent()
    1634             : {
    1635           0 :     const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 2;
    1636             :     OSL_ENSURE (bNodeCheck, "Sub has not two arguments");
    1637           0 :     if (!bNodeCheck)
    1638           0 :         return;
    1639             : 
    1640           0 :     SmToken aToken;
    1641           0 :     aToken.cMathChar = '\0';
    1642           0 :     aToken.nGroup = 0;
    1643           0 :     aToken.nLevel = 0;
    1644           0 :     aToken.eType = TACUTE;
    1645             : 
    1646           0 :     SmAttributNode *pNode = new SmAttributNode(aToken);
    1647           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
    1648             : 
    1649           0 :     SmNodeArray aSubNodes;
    1650           0 :     aSubNodes.resize(2);
    1651           0 :     aSubNodes[0] = lcl_popOrZero(rNodeStack);
    1652           0 :     aSubNodes[1] = lcl_popOrZero(rNodeStack);
    1653           0 :     pNode->SetSubNodes(aSubNodes);
    1654           0 :     pNode->SetScaleMode(SCALE_WIDTH);
    1655           0 :     rNodeStack.push(pNode);
    1656             : 
    1657             : }
    1658             : 
    1659             : ////////////////////////////////////////////////////////////
    1660             : 
    1661           0 : class SmXMLUnderOverContext_Impl : public SmXMLSubSupContext_Impl
    1662             : {
    1663             : public:
    1664           0 :     SmXMLUnderOverContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1665             :         const OUString& rLName)
    1666           0 :         : SmXMLSubSupContext_Impl(rImport,nPrefix,rLName) {}
    1667             : 
    1668           0 :     void EndElement()
    1669             :     {
    1670           0 :         GenericEndElement(TCSUB,CSUB,CSUP);
    1671           0 :     }
    1672             : };
    1673             : 
    1674             : ////////////////////////////////////////////////////////////
    1675             : 
    1676           0 : class SmXMLMultiScriptsContext_Impl : public SmXMLSubSupContext_Impl
    1677             : {
    1678             :     bool bHasPrescripts;
    1679             : 
    1680             :     void ProcessSubSupPairs(bool bIsPrescript);
    1681             : 
    1682             : public:
    1683           0 :     SmXMLMultiScriptsContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1684             :         const OUString& rLName) :
    1685             :         SmXMLSubSupContext_Impl(rImport,nPrefix,rLName),
    1686           0 :         bHasPrescripts(false) {}
    1687             : 
    1688             :     void EndElement();
    1689             :     SvXMLImportContext *CreateChildContext(sal_uInt16 nPrefix,
    1690             :         const OUString& rLocalName,
    1691             :         const uno::Reference< xml::sax::XAttributeList > &xAttrList);
    1692             : };
    1693             : 
    1694             : ////////////////////////////////////////////////////////////
    1695             : 
    1696           0 : class SmXMLNoneContext_Impl : public SmXMLImportContext
    1697             : {
    1698             : public:
    1699           0 :     SmXMLNoneContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1700             :         const OUString& rLName)
    1701           0 :         : SmXMLImportContext(rImport,nPrefix,rLName) {}
    1702             : 
    1703             :     void EndElement();
    1704             : };
    1705             : 
    1706             : 
    1707           0 : void SmXMLNoneContext_Impl::EndElement(void)
    1708             : {
    1709           0 :     SmToken aToken;
    1710           0 :     aToken.cMathChar = '\0';
    1711           0 :     aToken.nGroup = 0;
    1712           0 :     aToken.aText = "";
    1713           0 :     aToken.nLevel = 5;
    1714           0 :     aToken.eType = TIDENT;
    1715           0 :     GetSmImport().GetNodeStack().push(
    1716           0 :         new SmTextNode(aToken,FNT_VARIABLE));
    1717           0 : }
    1718             : 
    1719             : ////////////////////////////////////////////////////////////
    1720             : 
    1721           0 : class SmXMLPrescriptsContext_Impl : public SmXMLImportContext
    1722             : {
    1723             : public:
    1724           0 :     SmXMLPrescriptsContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1725             :         const OUString& rLName)
    1726           0 :         : SmXMLImportContext(rImport,nPrefix,rLName) {}
    1727             : };
    1728             : 
    1729             : ////////////////////////////////////////////////////////////
    1730             : 
    1731           0 : class SmXMLTableRowContext_Impl : public SmXMLRowContext_Impl
    1732             : {
    1733             : public:
    1734           0 :     SmXMLTableRowContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1735             :         const OUString& rLName) :
    1736           0 :         SmXMLRowContext_Impl(rImport,nPrefix,rLName)
    1737           0 :         {}
    1738             : 
    1739             :     SvXMLImportContext *CreateChildContext(sal_uInt16 nPrefix,
    1740             :         const OUString& rLocalName,
    1741             :         const uno::Reference< xml::sax::XAttributeList > &xAttrList);
    1742             : };
    1743             : 
    1744             : 
    1745             : ////////////////////////////////////////////////////////////
    1746             : 
    1747           0 : class SmXMLTableContext_Impl : public SmXMLTableRowContext_Impl
    1748             : {
    1749             : public:
    1750           0 :     SmXMLTableContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1751             :         const OUString& rLName) :
    1752           0 :         SmXMLTableRowContext_Impl(rImport,nPrefix,rLName)
    1753           0 :         {}
    1754             : 
    1755             :     void EndElement();
    1756             :     SvXMLImportContext *CreateChildContext(sal_uInt16 nPrefix,
    1757             :         const OUString& rLocalName,
    1758             :         const uno::Reference< xml::sax::XAttributeList > &xAttrList);
    1759             : };
    1760             : 
    1761             : 
    1762             : ////////////////////////////////////////////////////////////
    1763             : 
    1764           0 : class SmXMLTableCellContext_Impl : public SmXMLRowContext_Impl
    1765             : {
    1766             : public:
    1767           0 :     SmXMLTableCellContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1768             :         const OUString& rLName) :
    1769           0 :         SmXMLRowContext_Impl(rImport,nPrefix,rLName)
    1770           0 :         {}
    1771             : };
    1772             : 
    1773             : ////////////////////////////////////////////////////////////
    1774             : 
    1775           0 : class SmXMLAlignGroupContext_Impl : public SmXMLRowContext_Impl
    1776             : {
    1777             : public:
    1778           0 :     SmXMLAlignGroupContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1779             :         const OUString& rLName) :
    1780           0 :         SmXMLRowContext_Impl(rImport,nPrefix,rLName)
    1781           0 :         {}
    1782             : 
    1783             :     /*Don't do anything with alignment for now*/
    1784           0 :     void EndElement()
    1785             :     {
    1786           0 :     }
    1787             : };
    1788             : 
    1789             : ////////////////////////////////////////////////////////////
    1790             : 
    1791           0 : class SmXMLActionContext_Impl : public SmXMLRowContext_Impl
    1792             : {
    1793             : public:
    1794           0 :     SmXMLActionContext_Impl(SmXMLImport &rImport,sal_uInt16 nPrefix,
    1795             :         const OUString& rLName) :
    1796           0 :         SmXMLRowContext_Impl(rImport,nPrefix,rLName)
    1797           0 :         {}
    1798             : 
    1799             :     void EndElement();
    1800             : };
    1801             : 
    1802             : ////////////////////////////////////////////////////////////
    1803             : 
    1804             : // NB: virtually inherit so we can multiply inherit properly
    1805             : //     in SmXMLFlatDocContext_Impl
    1806           0 : class SmXMLOfficeContext_Impl : public virtual SvXMLImportContext
    1807             : {
    1808             : public:
    1809           0 :     SmXMLOfficeContext_Impl( SmXMLImport &rImport, sal_uInt16 nPrfx,
    1810             :         const OUString& rLName)
    1811           0 :         : SvXMLImportContext(rImport,nPrfx,rLName) {}
    1812             : 
    1813             :     virtual SvXMLImportContext *CreateChildContext(sal_uInt16 nPrefix, const OUString& rLocalName, const uno::Reference< xml::sax::XAttributeList > &xAttrList);
    1814             : };
    1815             : 
    1816           0 : SvXMLImportContext *SmXMLOfficeContext_Impl::CreateChildContext(sal_uInt16 nPrefix,
    1817             :         const OUString& rLocalName,
    1818             :         const uno::Reference< xml::sax::XAttributeList > &xAttrList)
    1819             : {
    1820           0 :     SvXMLImportContext *pContext = 0;
    1821           0 :     if ( XML_NAMESPACE_OFFICE == nPrefix &&
    1822           0 :         rLocalName == GetXMLToken(XML_META) )
    1823             :     {
    1824             :         OSL_FAIL("XML_TOK_DOC_META: should not have come here, maybe document is invalid?");
    1825             :     }
    1826           0 :     else if ( XML_NAMESPACE_OFFICE == nPrefix &&
    1827           0 :         rLocalName == GetXMLToken(XML_SETTINGS) )
    1828             :     {
    1829           0 :         pContext = new XMLDocumentSettingsContext( GetImport(),
    1830             :                                     XML_NAMESPACE_OFFICE, rLocalName,
    1831           0 :                                     xAttrList );
    1832             :     }
    1833             :     else
    1834           0 :         pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
    1835             : 
    1836           0 :     return pContext;
    1837             : }
    1838             : 
    1839             : ////////////////////////////////////////////////////////////
    1840             : 
    1841             : // context for flat file xml format
    1842             : class SmXMLFlatDocContext_Impl
    1843             :     : public SmXMLOfficeContext_Impl, public SvXMLMetaDocumentContext
    1844             : {
    1845             : public:
    1846             :     SmXMLFlatDocContext_Impl( SmXMLImport& i_rImport,
    1847             :         sal_uInt16 i_nPrefix, const OUString & i_rLName,
    1848             :         const uno::Reference<document::XDocumentProperties>& i_xDocProps);
    1849             : 
    1850             :     virtual ~SmXMLFlatDocContext_Impl();
    1851             : 
    1852             :     virtual SvXMLImportContext *CreateChildContext(sal_uInt16 i_nPrefix, const OUString& i_rLocalName, const uno::Reference<xml::sax::XAttributeList>& i_xAttrList);
    1853             : };
    1854             : 
    1855           0 : SmXMLFlatDocContext_Impl::SmXMLFlatDocContext_Impl( SmXMLImport& i_rImport,
    1856             :         sal_uInt16 i_nPrefix, const OUString & i_rLName,
    1857             :         const uno::Reference<document::XDocumentProperties>& i_xDocProps) :
    1858             :     SvXMLImportContext(i_rImport, i_nPrefix, i_rLName),
    1859             :     SmXMLOfficeContext_Impl(i_rImport, i_nPrefix, i_rLName),
    1860             :     SvXMLMetaDocumentContext(i_rImport, i_nPrefix, i_rLName,
    1861           0 :         i_xDocProps)
    1862             : {
    1863           0 : }
    1864             : 
    1865           0 : SmXMLFlatDocContext_Impl::~SmXMLFlatDocContext_Impl()
    1866             : {
    1867           0 : }
    1868             : 
    1869           0 : SvXMLImportContext *SmXMLFlatDocContext_Impl::CreateChildContext(
    1870             :     sal_uInt16 i_nPrefix, const OUString& i_rLocalName,
    1871             :     const uno::Reference<xml::sax::XAttributeList>& i_xAttrList)
    1872             : {
    1873             :     // behave like meta base class iff we encounter office:meta
    1874           0 :     if ( XML_NAMESPACE_OFFICE == i_nPrefix &&
    1875           0 :             i_rLocalName == GetXMLToken(XML_META) )
    1876             :     {
    1877             :         return SvXMLMetaDocumentContext::CreateChildContext(
    1878           0 :                     i_nPrefix, i_rLocalName, i_xAttrList );
    1879             :     }
    1880             :     else
    1881             :     {
    1882             :         return SmXMLOfficeContext_Impl::CreateChildContext(
    1883           0 :                     i_nPrefix, i_rLocalName, i_xAttrList );
    1884             :     }
    1885             : }
    1886             : 
    1887             : ////////////////////////////////////////////////////////////
    1888             : 
    1889             : static SvXMLTokenMapEntry aPresLayoutElemTokenMap[] =
    1890             : {
    1891             :     { XML_NAMESPACE_MATH,   XML_SEMANTICS, XML_TOK_SEMANTICS },
    1892             :     { XML_NAMESPACE_MATH,   XML_MATH,      XML_TOK_MATH   },
    1893             :     { XML_NAMESPACE_MATH,   XML_MSTYLE,    XML_TOK_MSTYLE  },
    1894             :     { XML_NAMESPACE_MATH,   XML_MERROR,    XML_TOK_MERROR },
    1895             :     { XML_NAMESPACE_MATH,   XML_MPHANTOM,  XML_TOK_MPHANTOM },
    1896             :     { XML_NAMESPACE_MATH,   XML_MROW,      XML_TOK_MROW },
    1897             :     { XML_NAMESPACE_MATH,   XML_MFRAC,     XML_TOK_MFRAC },
    1898             :     { XML_NAMESPACE_MATH,   XML_MSQRT,     XML_TOK_MSQRT },
    1899             :     { XML_NAMESPACE_MATH,   XML_MROOT,     XML_TOK_MROOT },
    1900             :     { XML_NAMESPACE_MATH,   XML_MSUB,      XML_TOK_MSUB },
    1901             :     { XML_NAMESPACE_MATH,   XML_MSUP,      XML_TOK_MSUP },
    1902             :     { XML_NAMESPACE_MATH,   XML_MSUBSUP,   XML_TOK_MSUBSUP },
    1903             :     { XML_NAMESPACE_MATH,   XML_MUNDER,    XML_TOK_MUNDER },
    1904             :     { XML_NAMESPACE_MATH,   XML_MOVER,     XML_TOK_MOVER },
    1905             :     { XML_NAMESPACE_MATH,   XML_MUNDEROVER,    XML_TOK_MUNDEROVER },
    1906             :     { XML_NAMESPACE_MATH,   XML_MMULTISCRIPTS, XML_TOK_MMULTISCRIPTS },
    1907             :     { XML_NAMESPACE_MATH,   XML_MTABLE,    XML_TOK_MTABLE },
    1908             :     { XML_NAMESPACE_MATH,   XML_MACTION,   XML_TOK_MACTION },
    1909             :     { XML_NAMESPACE_MATH,   XML_MFENCED,   XML_TOK_MFENCED },
    1910             :     { XML_NAMESPACE_MATH,   XML_MPADDED,   XML_TOK_MPADDED },
    1911             :     XML_TOKEN_MAP_END
    1912             : };
    1913             : 
    1914             : static SvXMLTokenMapEntry aPresLayoutAttrTokenMap[] =
    1915             : {
    1916             :     { XML_NAMESPACE_MATH,   XML_FONTWEIGHT,      XML_TOK_FONTWEIGHT    },
    1917             :     { XML_NAMESPACE_MATH,   XML_FONTSTYLE,       XML_TOK_FONTSTYLE     },
    1918             :     { XML_NAMESPACE_MATH,   XML_FONTSIZE,        XML_TOK_FONTSIZE      },
    1919             :     { XML_NAMESPACE_MATH,   XML_FONTFAMILY,      XML_TOK_FONTFAMILY    },
    1920             :     { XML_NAMESPACE_MATH,   XML_COLOR,           XML_TOK_COLOR },
    1921             :     XML_TOKEN_MAP_END
    1922             : };
    1923             : 
    1924             : static SvXMLTokenMapEntry aFencedAttrTokenMap[] =
    1925             : {
    1926             :     { XML_NAMESPACE_MATH,   XML_OPEN,       XML_TOK_OPEN },
    1927             :     { XML_NAMESPACE_MATH,   XML_CLOSE,      XML_TOK_CLOSE },
    1928             :     XML_TOKEN_MAP_END
    1929             : };
    1930             : 
    1931             : static SvXMLTokenMapEntry aOperatorAttrTokenMap[] =
    1932             : {
    1933             :     { XML_NAMESPACE_MATH,   XML_STRETCHY,      XML_TOK_STRETCHY },
    1934             :     XML_TOKEN_MAP_END
    1935             : };
    1936             : 
    1937             : static SvXMLTokenMapEntry aAnnotationAttrTokenMap[] =
    1938             : {
    1939             :     { XML_NAMESPACE_MATH,   XML_ENCODING,      XML_TOK_ENCODING },
    1940             :     XML_TOKEN_MAP_END
    1941             : };
    1942             : 
    1943             : 
    1944             : static SvXMLTokenMapEntry aPresElemTokenMap[] =
    1945             : {
    1946             :     { XML_NAMESPACE_MATH,   XML_ANNOTATION,    XML_TOK_ANNOTATION },
    1947             :     { XML_NAMESPACE_MATH,   XML_MI,    XML_TOK_MI },
    1948             :     { XML_NAMESPACE_MATH,   XML_MN,    XML_TOK_MN },
    1949             :     { XML_NAMESPACE_MATH,   XML_MO,    XML_TOK_MO },
    1950             :     { XML_NAMESPACE_MATH,   XML_MTEXT, XML_TOK_MTEXT },
    1951             :     { XML_NAMESPACE_MATH,   XML_MSPACE,XML_TOK_MSPACE },
    1952             :     { XML_NAMESPACE_MATH,   XML_MS,    XML_TOK_MS },
    1953             :     { XML_NAMESPACE_MATH,   XML_MALIGNGROUP,   XML_TOK_MALIGNGROUP },
    1954             :     XML_TOKEN_MAP_END
    1955             : };
    1956             : 
    1957             : static SvXMLTokenMapEntry aPresScriptEmptyElemTokenMap[] =
    1958             : {
    1959             :     { XML_NAMESPACE_MATH,   XML_MPRESCRIPTS,   XML_TOK_MPRESCRIPTS },
    1960             :     { XML_NAMESPACE_MATH,   XML_NONE,  XML_TOK_NONE },
    1961             :     XML_TOKEN_MAP_END
    1962             : };
    1963             : 
    1964             : static SvXMLTokenMapEntry aPresTableElemTokenMap[] =
    1965             : {
    1966             :     { XML_NAMESPACE_MATH,   XML_MTR,       XML_TOK_MTR },
    1967             :     { XML_NAMESPACE_MATH,   XML_MTD,       XML_TOK_MTD },
    1968             :     XML_TOKEN_MAP_END
    1969             : };
    1970             : 
    1971             : static SvXMLTokenMapEntry aColorTokenMap[] =
    1972             : {
    1973             :     { XML_NAMESPACE_MATH,   XML_BLACK,        TBLACK},
    1974             :     { XML_NAMESPACE_MATH,   XML_WHITE,        TWHITE},
    1975             :     { XML_NAMESPACE_MATH,   XML_RED,          TRED},
    1976             :     { XML_NAMESPACE_MATH,   XML_GREEN,        TGREEN},
    1977             :     { XML_NAMESPACE_MATH,   XML_BLUE,         TBLUE},
    1978             :     { XML_NAMESPACE_MATH,   XML_AQUA,         TCYAN},
    1979             :     { XML_NAMESPACE_MATH,   XML_FUCHSIA,      TMAGENTA},
    1980             :     { XML_NAMESPACE_MATH,   XML_YELLOW,       TYELLOW},
    1981             :     XML_TOKEN_MAP_END
    1982             : };
    1983             : 
    1984             : 
    1985             : ////////////////////////////////////////////////////////////
    1986             : 
    1987           0 : const SvXMLTokenMap& SmXMLImport::GetPresLayoutElemTokenMap()
    1988             : {
    1989           0 :     if (!pPresLayoutElemTokenMap)
    1990           0 :         pPresLayoutElemTokenMap = new SvXMLTokenMap(aPresLayoutElemTokenMap);
    1991           0 :     return *pPresLayoutElemTokenMap;
    1992             : }
    1993             : 
    1994           0 : const SvXMLTokenMap& SmXMLImport::GetPresLayoutAttrTokenMap()
    1995             : {
    1996           0 :     if (!pPresLayoutAttrTokenMap)
    1997           0 :         pPresLayoutAttrTokenMap = new SvXMLTokenMap(aPresLayoutAttrTokenMap);
    1998           0 :     return *pPresLayoutAttrTokenMap;
    1999             : }
    2000             : 
    2001             : 
    2002           0 : const SvXMLTokenMap& SmXMLImport::GetFencedAttrTokenMap()
    2003             : {
    2004           0 :     if (!pFencedAttrTokenMap)
    2005           0 :         pFencedAttrTokenMap = new SvXMLTokenMap(aFencedAttrTokenMap);
    2006           0 :     return *pFencedAttrTokenMap;
    2007             : }
    2008             : 
    2009           0 : const SvXMLTokenMap& SmXMLImport::GetOperatorAttrTokenMap()
    2010             : {
    2011           0 :     if (!pOperatorAttrTokenMap)
    2012           0 :         pOperatorAttrTokenMap = new SvXMLTokenMap(aOperatorAttrTokenMap);
    2013           0 :     return *pOperatorAttrTokenMap;
    2014             : }
    2015             : 
    2016           0 : const SvXMLTokenMap& SmXMLImport::GetAnnotationAttrTokenMap()
    2017             : {
    2018           0 :     if (!pAnnotationAttrTokenMap)
    2019           0 :         pAnnotationAttrTokenMap = new SvXMLTokenMap(aAnnotationAttrTokenMap);
    2020           0 :     return *pAnnotationAttrTokenMap;
    2021             : }
    2022             : 
    2023           0 : const SvXMLTokenMap& SmXMLImport::GetPresElemTokenMap()
    2024             : {
    2025           0 :     if (!pPresElemTokenMap)
    2026           0 :         pPresElemTokenMap = new SvXMLTokenMap(aPresElemTokenMap);
    2027           0 :     return *pPresElemTokenMap;
    2028             : }
    2029             : 
    2030           0 : const SvXMLTokenMap& SmXMLImport::GetPresScriptEmptyElemTokenMap()
    2031             : {
    2032           0 :     if (!pPresScriptEmptyElemTokenMap)
    2033             :         pPresScriptEmptyElemTokenMap = new
    2034           0 :             SvXMLTokenMap(aPresScriptEmptyElemTokenMap);
    2035           0 :     return *pPresScriptEmptyElemTokenMap;
    2036             : }
    2037             : 
    2038           0 : const SvXMLTokenMap& SmXMLImport::GetPresTableElemTokenMap()
    2039             : {
    2040           0 :     if (!pPresTableElemTokenMap)
    2041           0 :         pPresTableElemTokenMap = new SvXMLTokenMap(aPresTableElemTokenMap);
    2042           0 :     return *pPresTableElemTokenMap;
    2043             : }
    2044             : 
    2045           0 : const SvXMLTokenMap& SmXMLImport::GetColorTokenMap()
    2046             : {
    2047           0 :     if (!pColorTokenMap)
    2048           0 :         pColorTokenMap = new SvXMLTokenMap(aColorTokenMap);
    2049           0 :     return *pColorTokenMap;
    2050             : }
    2051             : 
    2052             : ////////////////////////////////////////////////////////////
    2053             : 
    2054           0 : SvXMLImportContext *SmXMLDocContext_Impl::CreateChildContext(
    2055             :     sal_uInt16 nPrefix,
    2056             :     const OUString& rLocalName,
    2057             :     const uno::Reference<xml::sax::XAttributeList>& xAttrList)
    2058             : {
    2059           0 :     SvXMLImportContext* pContext = 0L;
    2060             : 
    2061           0 :     const SvXMLTokenMap& rTokenMap = GetSmImport().GetPresLayoutElemTokenMap();
    2062             : 
    2063           0 :     switch(rTokenMap.Get(nPrefix, rLocalName))
    2064             :     {
    2065             :         //Consider semantics a dummy except for any starmath annotations
    2066             :         case XML_TOK_SEMANTICS:
    2067           0 :             pContext = GetSmImport().CreateRowContext(nPrefix,rLocalName,
    2068           0 :                 xAttrList);
    2069             :             break;
    2070             :         /*General Layout Schemata*/
    2071             :         case XML_TOK_MROW:
    2072           0 :             pContext = GetSmImport().CreateRowContext(nPrefix,rLocalName,
    2073           0 :                 xAttrList);
    2074             :             break;
    2075             :         case XML_TOK_MFRAC:
    2076           0 :             pContext = GetSmImport().CreateFracContext(nPrefix,rLocalName,
    2077           0 :                 xAttrList);
    2078             :             break;
    2079             :         case XML_TOK_MSQRT:
    2080           0 :             pContext = GetSmImport().CreateSqrtContext(nPrefix,rLocalName,
    2081           0 :                 xAttrList);
    2082             :             break;
    2083             :         case XML_TOK_MROOT:
    2084           0 :             pContext = GetSmImport().CreateRootContext(nPrefix,rLocalName,
    2085           0 :                 xAttrList);
    2086             :             break;
    2087             :         case XML_TOK_MSTYLE:
    2088           0 :             pContext = GetSmImport().CreateStyleContext(nPrefix,rLocalName,
    2089           0 :                 xAttrList);
    2090             :             break;
    2091             :         case XML_TOK_MERROR:
    2092           0 :             pContext = GetSmImport().CreateErrorContext(nPrefix,rLocalName,
    2093           0 :                 xAttrList);
    2094             :             break;
    2095             :         case XML_TOK_MPADDED:
    2096           0 :             pContext = GetSmImport().CreatePaddedContext(nPrefix,rLocalName,
    2097           0 :                 xAttrList);
    2098             :             break;
    2099             :         case XML_TOK_MPHANTOM:
    2100           0 :             pContext = GetSmImport().CreatePhantomContext(nPrefix,rLocalName,
    2101           0 :                 xAttrList);
    2102             :             break;
    2103             :         case XML_TOK_MFENCED:
    2104           0 :             pContext = GetSmImport().CreateFencedContext(nPrefix,rLocalName,
    2105           0 :                 xAttrList);
    2106             :             break;
    2107             :         /*Script and Limit Schemata*/
    2108             :         case XML_TOK_MSUB:
    2109           0 :             pContext = GetSmImport().CreateSubContext(nPrefix,rLocalName,
    2110           0 :                 xAttrList);
    2111             :             break;
    2112             :         case XML_TOK_MSUP:
    2113           0 :             pContext = GetSmImport().CreateSupContext(nPrefix,rLocalName,
    2114           0 :                 xAttrList);
    2115             :             break;
    2116             :         case XML_TOK_MSUBSUP:
    2117           0 :             pContext = GetSmImport().CreateSubSupContext(nPrefix,rLocalName,
    2118           0 :                 xAttrList);
    2119             :             break;
    2120             :         case XML_TOK_MUNDER:
    2121           0 :             pContext = GetSmImport().CreateUnderContext(nPrefix,rLocalName,
    2122           0 :                 xAttrList);
    2123             :             break;
    2124             :         case XML_TOK_MOVER:
    2125           0 :             pContext = GetSmImport().CreateOverContext(nPrefix,rLocalName,
    2126           0 :                 xAttrList);
    2127             :             break;
    2128             :         case XML_TOK_MUNDEROVER:
    2129           0 :             pContext = GetSmImport().CreateUnderOverContext(nPrefix,rLocalName,
    2130           0 :                 xAttrList);
    2131             :             break;
    2132             :         case XML_TOK_MMULTISCRIPTS:
    2133           0 :             pContext = GetSmImport().CreateMultiScriptsContext(nPrefix,
    2134           0 :                 rLocalName, xAttrList);
    2135             :             break;
    2136             :         case XML_TOK_MTABLE:
    2137           0 :             pContext = GetSmImport().CreateTableContext(nPrefix,
    2138           0 :                 rLocalName, xAttrList);
    2139             :             break;
    2140             :         case XML_TOK_MACTION:
    2141           0 :             pContext = GetSmImport().CreateActionContext(nPrefix,
    2142           0 :                 rLocalName, xAttrList);
    2143             :             break;
    2144             :         default:
    2145             :             /*Basically theres an implicit mrow around certain bare
    2146             :              *elements, use a RowContext to see if this is one of
    2147             :              *those ones*/
    2148           0 :             SmXMLRowContext_Impl aTempContext(GetSmImport(),nPrefix,
    2149           0 :                 GetXMLToken(XML_MROW));
    2150             : 
    2151             :             pContext = aTempContext.StrictCreateChildContext(nPrefix,
    2152           0 :                 rLocalName, xAttrList);
    2153           0 :             break;
    2154             :     }
    2155           0 :     return pContext;
    2156             : }
    2157             : 
    2158           0 : void SmXMLDocContext_Impl::EndElement()
    2159             : {
    2160           0 :     SmNodeArray ContextArray;
    2161           0 :     ContextArray.resize(1);
    2162           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
    2163             : 
    2164           0 :     ContextArray[0] = lcl_popOrZero(rNodeStack);
    2165             : 
    2166           0 :     SmToken aDummy;
    2167           0 :     SmStructureNode *pSNode = new SmLineNode(aDummy);
    2168           0 :     pSNode->SetSubNodes(ContextArray);
    2169           0 :     rNodeStack.push(pSNode);
    2170             : 
    2171           0 :     SmNodeArray  LineArray;
    2172           0 :     sal_uLong n = rNodeStack.size();
    2173           0 :     LineArray.resize(n);
    2174           0 :     for (sal_uLong j = 0; j < n; j++)
    2175             :     {
    2176           0 :         LineArray[n - (j + 1)] = rNodeStack.top();
    2177           0 :         rNodeStack.pop();
    2178             :     }
    2179           0 :     SmStructureNode *pSNode2 = new SmTableNode(aDummy);
    2180           0 :     pSNode2->SetSubNodes(LineArray);
    2181           0 :     rNodeStack.push(pSNode2);
    2182           0 : }
    2183             : 
    2184           0 : void SmXMLFracContext_Impl::EndElement()
    2185             : {
    2186           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
    2187           0 :     const bool bNodeCheck = rNodeStack.size() - nElementCount == 2;
    2188             :     OSL_ENSURE( bNodeCheck, "Fraction (mfrac) tag is missing component" );
    2189           0 :     if (!bNodeCheck)
    2190           0 :         return;
    2191             : 
    2192           0 :     SmToken aToken;
    2193           0 :     aToken.cMathChar = '\0';
    2194           0 :     aToken.nGroup = 0;
    2195           0 :     aToken.nLevel = 0;
    2196           0 :     aToken.eType = TOVER;
    2197           0 :     SmStructureNode *pSNode = new SmBinVerNode(aToken);
    2198           0 :     SmNode *pOper = new SmRectangleNode(aToken);
    2199           0 :     SmNode *pSecond = lcl_popOrZero(rNodeStack);
    2200           0 :     SmNode *pFirst = lcl_popOrZero(rNodeStack);
    2201           0 :     pSNode->SetSubNodes(pFirst,pOper,pSecond);
    2202           0 :     rNodeStack.push(pSNode);
    2203             : }
    2204             : 
    2205           0 : void SmXMLRootContext_Impl::EndElement()
    2206             : {
    2207             :     /*The <mroot> element requires exactly 2 arguments.*/
    2208           0 :     const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 2;
    2209             :     OSL_ENSURE( bNodeCheck, "Root tag is missing component");
    2210           0 :     if (!bNodeCheck)
    2211           0 :         return;
    2212             : 
    2213           0 :     SmToken aToken;
    2214           0 :     aToken.cMathChar = MS_SQRT;  //Temporary: alert, based on StarSymbol font
    2215           0 :     aToken.nGroup = 0;
    2216           0 :     aToken.nLevel = 0;
    2217           0 :     aToken.eType = TNROOT;
    2218           0 :     SmStructureNode *pSNode = new SmRootNode(aToken);
    2219           0 :     SmNode *pOper = new SmRootSymbolNode(aToken);
    2220           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
    2221           0 :     SmNode *pIndex = lcl_popOrZero(rNodeStack);
    2222           0 :     SmNode *pBase = lcl_popOrZero(rNodeStack);
    2223           0 :     pSNode->SetSubNodes(pIndex,pOper,pBase);
    2224           0 :     rNodeStack.push(pSNode);
    2225             : }
    2226             : 
    2227           0 : void SmXMLSqrtContext_Impl::EndElement()
    2228             : {
    2229             :     /*
    2230             :     <msqrt> accepts any number of arguments; if this number is not 1, its
    2231             :     contents are treated as a single "inferred <mrow>" containing its
    2232             :     arguments
    2233             :     */
    2234           0 :     if (GetSmImport().GetNodeStack().size() - nElementCount > 1)
    2235           0 :         SmXMLRowContext_Impl::EndElement();
    2236             : 
    2237           0 :     SmToken aToken;
    2238           0 :     aToken.cMathChar = MS_SQRT;  //Temporary: alert, based on StarSymbol font
    2239           0 :     aToken.nGroup = 0;
    2240           0 :     aToken.nLevel = 0;
    2241           0 :     aToken.eType = TSQRT;
    2242           0 :     SmStructureNode *pSNode = new SmRootNode(aToken);
    2243           0 :     SmNode *pOper = new SmRootSymbolNode(aToken);
    2244           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
    2245           0 :     pSNode->SetSubNodes(0,pOper,lcl_popOrZero(rNodeStack));
    2246           0 :     rNodeStack.push(pSNode);
    2247           0 : }
    2248             : 
    2249           0 : void SmXMLRowContext_Impl::EndElement()
    2250             : {
    2251           0 :     SmNodeArray aRelationArray;
    2252           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
    2253           0 :     sal_uLong nSize = rNodeStack.size()-nElementCount;
    2254             : 
    2255           0 :     if (nSize > 0)
    2256             :     {
    2257           0 :         aRelationArray.resize(nSize);
    2258           0 :         for (sal_uLong j=nSize;j > 0;j--)
    2259             :         {
    2260           0 :             aRelationArray[j-1] = rNodeStack.top();
    2261           0 :             rNodeStack.pop();
    2262             :         }
    2263             : 
    2264             :         //If the first or last element is an operator with stretchyness
    2265             :         //set then we must create a brace node here from those elements,
    2266             :         //removing the stretchness from the operators and applying it to
    2267             :         //ourselves, and creating the appropriate dummy StarMath none bracket
    2268             :         //to balance the arrangement
    2269           0 :         if (((aRelationArray[0]->GetScaleMode() == SCALE_HEIGHT)
    2270           0 :             && (aRelationArray[0]->GetType() == NMATH))
    2271           0 :         || ((aRelationArray[nSize-1]->GetScaleMode() == SCALE_HEIGHT)
    2272           0 :             && (aRelationArray[nSize-1]->GetType() == NMATH)))
    2273             :         {
    2274           0 :             SmToken aToken;
    2275           0 :             aToken.cMathChar = '\0';
    2276           0 :             aToken.nGroup = 0;
    2277           0 :             aToken.nLevel = 5;
    2278             : 
    2279           0 :             int nLeft=0,nRight=0;
    2280           0 :             if ((aRelationArray[0]->GetScaleMode() == SCALE_HEIGHT)
    2281           0 :                 && (aRelationArray[0]->GetType() == NMATH))
    2282             :             {
    2283           0 :                 aToken = aRelationArray[0]->GetToken();
    2284           0 :                 nLeft=1;
    2285             :             }
    2286             :             else
    2287           0 :                 aToken.cMathChar = '\0';
    2288             : 
    2289           0 :             aToken.eType = TLPARENT;
    2290           0 :             SmNode *pLeft = new SmMathSymbolNode(aToken);
    2291             : 
    2292           0 :             if ((aRelationArray[nSize-1]->GetScaleMode() == SCALE_HEIGHT)
    2293           0 :                 && (aRelationArray[nSize-1]->GetType() == NMATH))
    2294             :             {
    2295           0 :                 aToken = aRelationArray[nSize-1]->GetToken();
    2296           0 :                 nRight=1;
    2297             :             }
    2298             :             else
    2299           0 :                 aToken.cMathChar = '\0';
    2300             : 
    2301           0 :             aToken.eType = TRPARENT;
    2302           0 :             SmNode *pRight = new SmMathSymbolNode(aToken);
    2303             : 
    2304           0 :             SmNodeArray aRelationArray2;
    2305             : 
    2306             :             //!! nSize-nLeft-nRight may be < 0 !!
    2307           0 :             int nRelArrSize = nSize-nLeft-nRight;
    2308           0 :             if (nRelArrSize > 0)
    2309             :             {
    2310           0 :                 aRelationArray2.resize(nRelArrSize);
    2311           0 :                 for (int i=0;i < nRelArrSize;i++)
    2312           0 :                     aRelationArray2[i] = aRelationArray[i+nLeft];
    2313             :             }
    2314             : 
    2315           0 :             SmToken aDummy;
    2316           0 :             SmStructureNode *pSNode = new SmBraceNode(aToken);
    2317           0 :             SmStructureNode *pBody = new SmExpressionNode(aDummy);
    2318           0 :             pBody->SetSubNodes(aRelationArray2);
    2319             : 
    2320           0 :             pSNode->SetSubNodes(pLeft,pBody,pRight);
    2321           0 :             pSNode->SetScaleMode(SCALE_HEIGHT);
    2322           0 :             rNodeStack.push(pSNode);
    2323           0 :             return;
    2324             :         }
    2325             :     }
    2326             :     else //Multiple newlines result in empty row elements
    2327             :     {
    2328           0 :         aRelationArray.resize(1);
    2329           0 :         SmToken aToken;
    2330           0 :         aToken.cMathChar = '\0';
    2331           0 :         aToken.nGroup = 0;
    2332           0 :         aToken.nLevel = 5;
    2333           0 :         aToken.eType = TNEWLINE;
    2334           0 :         aRelationArray[0] = new SmLineNode(aToken);
    2335             :     }
    2336             : 
    2337           0 :     SmToken aDummy;
    2338           0 :     SmStructureNode *pSNode = new SmExpressionNode(aDummy);
    2339           0 :     pSNode->SetSubNodes(aRelationArray);
    2340           0 :     rNodeStack.push(pSNode);
    2341             : }
    2342             : 
    2343             : 
    2344           0 : SvXMLImportContext *SmXMLRowContext_Impl::StrictCreateChildContext(
    2345             :     sal_uInt16 nPrefix,
    2346             :     const OUString& rLocalName,
    2347             :     const uno::Reference<xml::sax::XAttributeList>& xAttrList)
    2348             : {
    2349           0 :     SvXMLImportContext* pContext = 0L;
    2350             : 
    2351           0 :     const SvXMLTokenMap& rTokenMap = GetSmImport().GetPresElemTokenMap();
    2352           0 :     switch(rTokenMap.Get(nPrefix, rLocalName))
    2353             :     {
    2354             :         /*Note that these should accept malignmark subelements, but do not*/
    2355             :         case XML_TOK_MN:
    2356           0 :             pContext = GetSmImport().CreateNumberContext(nPrefix,rLocalName,
    2357           0 :                 xAttrList);
    2358           0 :             break;
    2359             :         case XML_TOK_MI:
    2360           0 :             pContext = GetSmImport().CreateIdentifierContext(nPrefix,rLocalName,
    2361           0 :                 xAttrList);
    2362           0 :             break;
    2363             :         case XML_TOK_MO:
    2364           0 :             pContext = GetSmImport().CreateOperatorContext(nPrefix,rLocalName,
    2365           0 :                 xAttrList);
    2366           0 :             break;
    2367             :         case XML_TOK_MTEXT:
    2368           0 :             pContext = GetSmImport().CreateTextContext(nPrefix,rLocalName,
    2369           0 :                 xAttrList);
    2370           0 :             break;
    2371             :         case XML_TOK_MSPACE:
    2372           0 :             pContext = GetSmImport().CreateSpaceContext(nPrefix,rLocalName,
    2373           0 :                 xAttrList);
    2374           0 :             break;
    2375             :         case XML_TOK_MS:
    2376           0 :             pContext = GetSmImport().CreateStringContext(nPrefix,rLocalName,
    2377           0 :                 xAttrList);
    2378           0 :             break;
    2379             : 
    2380             :         /*Note: The maligngroup should only be seen when the row
    2381             :          * (or decendants) are in a table*/
    2382             :         case XML_TOK_MALIGNGROUP:
    2383           0 :             pContext = GetSmImport().CreateAlignGroupContext(nPrefix,rLocalName,
    2384           0 :                 xAttrList);
    2385           0 :             break;
    2386             : 
    2387             :         case XML_TOK_ANNOTATION:
    2388           0 :             pContext = GetSmImport().CreateAnnotationContext(nPrefix,rLocalName,
    2389           0 :                 xAttrList);
    2390           0 :             break;
    2391             : 
    2392             :         default:
    2393           0 :             break;
    2394             :     }
    2395           0 :     return pContext;
    2396             : }
    2397             : 
    2398             : 
    2399           0 : SvXMLImportContext *SmXMLRowContext_Impl::CreateChildContext(
    2400             :     sal_uInt16 nPrefix,
    2401             :     const OUString& rLocalName,
    2402             :     const uno::Reference<xml::sax::XAttributeList>& xAttrList)
    2403             : {
    2404             :     SvXMLImportContext* pContext = StrictCreateChildContext(nPrefix,
    2405           0 :     rLocalName, xAttrList);
    2406             : 
    2407           0 :     if (!pContext)
    2408             :     {
    2409             :         //Hmm, unrecognized for this level, check to see if its
    2410             :         //an element that can have an implicit schema around it
    2411             :         pContext = SmXMLDocContext_Impl::CreateChildContext(nPrefix,
    2412           0 :             rLocalName,xAttrList);
    2413             :     }
    2414           0 :     return pContext;
    2415             : }
    2416             : 
    2417             : 
    2418           0 : SvXMLImportContext *SmXMLMultiScriptsContext_Impl::CreateChildContext(
    2419             :     sal_uInt16 nPrefix,
    2420             :     const OUString& rLocalName,
    2421             :     const uno::Reference<xml::sax::XAttributeList>& xAttrList)
    2422             : {
    2423           0 :     SvXMLImportContext* pContext = 0L;
    2424             : 
    2425           0 :     const SvXMLTokenMap& rTokenMap = GetSmImport().
    2426           0 :         GetPresScriptEmptyElemTokenMap();
    2427           0 :     switch(rTokenMap.Get(nPrefix, rLocalName))
    2428             :     {
    2429             :         case XML_TOK_MPRESCRIPTS:
    2430           0 :             bHasPrescripts = true;
    2431           0 :             ProcessSubSupPairs(false);
    2432           0 :             pContext = GetSmImport().CreatePrescriptsContext(nPrefix,
    2433           0 :                 rLocalName, xAttrList);
    2434           0 :             break;
    2435             :         case XML_TOK_NONE:
    2436           0 :             pContext = GetSmImport().CreateNoneContext(nPrefix,rLocalName,
    2437           0 :                 xAttrList);
    2438           0 :             break;
    2439             :         default:
    2440             :             pContext = SmXMLRowContext_Impl::CreateChildContext(nPrefix,
    2441           0 :                 rLocalName,xAttrList);
    2442           0 :             break;
    2443             :     }
    2444           0 :     return pContext;
    2445             : }
    2446             : 
    2447           0 : void SmXMLMultiScriptsContext_Impl::ProcessSubSupPairs(bool bIsPrescript)
    2448             : {
    2449           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
    2450             : 
    2451           0 :     if (rNodeStack.size() <= nElementCount)
    2452           0 :         return;
    2453             : 
    2454           0 :     sal_uLong nCount = rNodeStack.size() - nElementCount - 1;
    2455           0 :     if (nCount == 0)
    2456           0 :         return;
    2457             : 
    2458           0 :     if (nCount % 2 == 0)
    2459             :     {
    2460           0 :         SmToken aToken;
    2461           0 :         aToken.cMathChar = '\0';
    2462           0 :         aToken.nGroup = 0;
    2463           0 :         aToken.nLevel = 0;
    2464           0 :         aToken.eType = bIsPrescript ? TLSUB : TRSUB;
    2465             : 
    2466           0 :         SmNodeStack aReverseStack;
    2467           0 :         for (sal_uLong i = 0; i < nCount + 1; i++)
    2468             :         {
    2469           0 :             aReverseStack.push(rNodeStack.top());
    2470           0 :             rNodeStack.pop();
    2471             :         }
    2472             : 
    2473           0 :         SmSubSup eSub = bIsPrescript ? LSUB : RSUB;
    2474           0 :         SmSubSup eSup = bIsPrescript ? LSUP : RSUP;
    2475             : 
    2476           0 :         for (sal_uLong i = 0; i < nCount; i += 2)
    2477             :         {
    2478           0 :             SmSubSupNode *pNode = new SmSubSupNode(aToken);
    2479             : 
    2480             :             // initialize subnodes array
    2481           0 :             SmNodeArray aSubNodes(1 + SUBSUP_NUM_ENTRIES);
    2482             : 
    2483             :             /*On each loop the base and its sub sup pair becomes the
    2484             :              base for the next loop to which the next sub sup pair is
    2485             :              attached, i.e. wheels within wheels*/
    2486           0 :             aSubNodes[0] = lcl_popOrZero(aReverseStack);
    2487             : 
    2488           0 :             SmNode *pScriptNode = lcl_popOrZero(aReverseStack);
    2489             : 
    2490           0 :             if (pScriptNode && ((pScriptNode->GetToken().eType != TIDENT) ||
    2491           0 :                 (!pScriptNode->GetToken().aText.isEmpty())))
    2492           0 :                 aSubNodes[eSub+1] = pScriptNode;
    2493           0 :             pScriptNode = lcl_popOrZero(aReverseStack);
    2494           0 :             if (pScriptNode && ((pScriptNode->GetToken().eType != TIDENT) ||
    2495           0 :                 (!pScriptNode->GetToken().aText.isEmpty())))
    2496           0 :                 aSubNodes[eSup+1] = pScriptNode;
    2497             : 
    2498           0 :             pNode->SetSubNodes(aSubNodes);
    2499           0 :             aReverseStack.push(pNode);
    2500           0 :         }
    2501           0 :         rNodeStack.push(lcl_popOrZero(aReverseStack));
    2502             :     }
    2503             :     else
    2504             :     {
    2505             :         // Ignore odd number of elements.
    2506           0 :         for (sal_uLong i = 0; i < nCount; i++)
    2507             :         {
    2508           0 :             delete rNodeStack.top();
    2509           0 :             rNodeStack.pop();
    2510             :         }
    2511             :     }
    2512             : }
    2513             : 
    2514             : 
    2515           0 : void SmXMLTableContext_Impl::EndElement()
    2516             : {
    2517           0 :     SmNodeArray aExpressionArray;
    2518           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
    2519           0 :     SmNodeStack aReverseStack;
    2520           0 :     aExpressionArray.resize(rNodeStack.size()-nElementCount);
    2521             : 
    2522           0 :     sal_uLong nRows = rNodeStack.size()-nElementCount;
    2523           0 :     sal_uInt16 nCols = 0;
    2524             : 
    2525             :     SmStructureNode *pArray;
    2526           0 :     for (sal_uLong i=nRows;i > 0;i--)
    2527             :     {
    2528           0 :         pArray = (SmStructureNode *)rNodeStack.top();
    2529           0 :         rNodeStack.pop();
    2530           0 :         if (pArray->GetNumSubNodes() == 0)
    2531             :         {
    2532             :             //This is a little tricky, it is possible that there was
    2533             :             //be elements that were not inside a <mtd> pair, in which
    2534             :             //case they will not be in a row, i.e. they will not have
    2535             :             //SubNodes, so we have to wait until here before we can
    2536             :             //resolve the situation. Implicitsurrounding tags are
    2537             :             //surprisingly difficult to get right within this
    2538             :             //architecture
    2539             : 
    2540           0 :             SmNodeArray aRelationArray;
    2541           0 :             aRelationArray.resize(1);
    2542           0 :             aRelationArray[0] = pArray;
    2543           0 :             SmToken aDummy;
    2544           0 :             pArray = new SmExpressionNode(aDummy);
    2545           0 :             pArray->SetSubNodes(aRelationArray);
    2546             :         }
    2547             : 
    2548           0 :         if (pArray->GetNumSubNodes() > nCols)
    2549           0 :             nCols = pArray->GetNumSubNodes();
    2550           0 :         aReverseStack.push(pArray);
    2551             :     }
    2552           0 :     aExpressionArray.resize(nCols*nRows);
    2553           0 :     sal_uLong j=0;
    2554           0 :     while ( !aReverseStack.empty() )
    2555             :     {
    2556           0 :         pArray = (SmStructureNode *)aReverseStack.top();
    2557           0 :         aReverseStack.pop();
    2558           0 :         for (sal_uInt16 i=0;i<pArray->GetNumSubNodes();i++)
    2559           0 :             aExpressionArray[j++] = pArray->GetSubNode(i);
    2560             :     }
    2561             : 
    2562           0 :     SmToken aToken;
    2563           0 :     aToken.cMathChar = '\0';
    2564           0 :     aToken.nGroup = TRGROUP;
    2565           0 :     aToken.nLevel = 0;
    2566           0 :     aToken.eType = TMATRIX;
    2567           0 :     SmMatrixNode *pSNode = new SmMatrixNode(aToken);
    2568           0 :     pSNode->SetSubNodes(aExpressionArray);
    2569           0 :     pSNode->SetRowCol(static_cast<sal_uInt16>(nRows),nCols);
    2570           0 :     rNodeStack.push(pSNode);
    2571           0 : }
    2572             : 
    2573           0 : SvXMLImportContext *SmXMLTableRowContext_Impl::CreateChildContext(
    2574             :     sal_uInt16 nPrefix,
    2575             :     const OUString& rLocalName,
    2576             :     const uno::Reference<xml::sax::XAttributeList>& xAttrList)
    2577             : {
    2578           0 :     SvXMLImportContext* pContext = 0L;
    2579             : 
    2580           0 :     const SvXMLTokenMap& rTokenMap = GetSmImport().
    2581           0 :         GetPresTableElemTokenMap();
    2582           0 :     switch(rTokenMap.Get(nPrefix, rLocalName))
    2583             :     {
    2584             :         case XML_TOK_MTD:
    2585           0 :             pContext = GetSmImport().CreateTableCellContext(nPrefix,
    2586           0 :                 rLocalName, xAttrList);
    2587           0 :             break;
    2588             :         default:
    2589             :             pContext = SmXMLRowContext_Impl::CreateChildContext(nPrefix,
    2590           0 :                 rLocalName,xAttrList);
    2591           0 :             break;
    2592             :     }
    2593           0 :     return pContext;
    2594             : }
    2595             : 
    2596           0 : SvXMLImportContext *SmXMLTableContext_Impl::CreateChildContext(
    2597             :     sal_uInt16 nPrefix,
    2598             :     const OUString& rLocalName,
    2599             :     const uno::Reference<xml::sax::XAttributeList>& xAttrList)
    2600             : {
    2601           0 :     SvXMLImportContext* pContext = 0L;
    2602             : 
    2603           0 :     const SvXMLTokenMap& rTokenMap = GetSmImport().
    2604           0 :         GetPresTableElemTokenMap();
    2605           0 :     switch(rTokenMap.Get(nPrefix, rLocalName))
    2606             :     {
    2607             :         case XML_TOK_MTR:
    2608           0 :             pContext = GetSmImport().CreateTableRowContext(nPrefix,rLocalName,
    2609           0 :                 xAttrList);
    2610           0 :             break;
    2611             :         default:
    2612             :             pContext = SmXMLTableRowContext_Impl::CreateChildContext(nPrefix,
    2613           0 :                 rLocalName,xAttrList);
    2614           0 :             break;
    2615             :     }
    2616           0 :     return pContext;
    2617             : }
    2618             : 
    2619           0 : void SmXMLMultiScriptsContext_Impl::EndElement()
    2620             : {
    2621           0 :     ProcessSubSupPairs(bHasPrescripts);
    2622           0 : }
    2623             : 
    2624           0 : void SmXMLActionContext_Impl::EndElement()
    2625             : {
    2626             :     /*For now we will just assume that the
    2627             :      selected attribute is one, and then just display
    2628             :      that expression alone, i.e. remove all expect the
    2629             :      first pushed one*/
    2630             : 
    2631           0 :     SmNodeStack &rNodeStack = GetSmImport().GetNodeStack();
    2632           0 :     for (sal_uLong i=rNodeStack.size()-nElementCount;i > 1;i--)
    2633             :     {
    2634           0 :         delete rNodeStack.top();
    2635           0 :         rNodeStack.pop();
    2636             :     }
    2637           0 : }
    2638             : 
    2639           0 : SvXMLImportContext *SmXMLImport::CreateContext(sal_uInt16 nPrefix,
    2640             :     const OUString &rLocalName,
    2641             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2642             : {
    2643           0 :     if ( XML_NAMESPACE_OFFICE == nPrefix )
    2644             :     {
    2645           0 :         if ( (IsXMLToken(rLocalName, XML_DOCUMENT) ||
    2646           0 :               IsXMLToken(rLocalName, XML_DOCUMENT_META)))
    2647             :         {
    2648             :             uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
    2649           0 :                 GetModel(), uno::UNO_QUERY_THROW);
    2650           0 :             return IsXMLToken(rLocalName, XML_DOCUMENT_META)
    2651             :                 ? new SvXMLMetaDocumentContext(*this,
    2652             :                         XML_NAMESPACE_OFFICE, rLocalName,
    2653           0 :                         xDPS->getDocumentProperties())
    2654             :                 // flat OpenDocument file format -- this has not been tested...
    2655             :                 : new SmXMLFlatDocContext_Impl( *this, nPrefix, rLocalName,
    2656           0 :                             xDPS->getDocumentProperties());
    2657             :         }
    2658             :         else
    2659             :         {
    2660           0 :             return new SmXMLOfficeContext_Impl( *this,nPrefix,rLocalName);
    2661             :         }
    2662             :     }
    2663             :     else
    2664           0 :         return new SmXMLDocContext_Impl(*this,nPrefix,rLocalName);
    2665             : }
    2666             : 
    2667           0 : SvXMLImportContext *SmXMLImport::CreateRowContext(sal_uInt16 nPrefix,
    2668             :     const OUString &rLocalName,
    2669             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2670             : {
    2671           0 :         return new SmXMLRowContext_Impl(*this,nPrefix,rLocalName);
    2672             : }
    2673             : 
    2674           0 : SvXMLImportContext *SmXMLImport::CreateTextContext(sal_uInt16 nPrefix,
    2675             :     const OUString &rLocalName,
    2676             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2677             : {
    2678           0 :     return new SmXMLTextContext_Impl(*this,nPrefix,rLocalName);
    2679             : }
    2680             : 
    2681           0 : SvXMLImportContext *SmXMLImport::CreateAnnotationContext(sal_uInt16 nPrefix,
    2682             :     const OUString &rLocalName,
    2683             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2684             : {
    2685           0 :     return new SmXMLAnnotationContext_Impl(*this,nPrefix,rLocalName);
    2686             : }
    2687             : 
    2688           0 : SvXMLImportContext *SmXMLImport::CreateStringContext(sal_uInt16 nPrefix,
    2689             :     const OUString &rLocalName,
    2690             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2691             : {
    2692           0 :     return new SmXMLStringContext_Impl(*this,nPrefix,rLocalName);
    2693             : }
    2694             : 
    2695           0 : SvXMLImportContext *SmXMLImport::CreateNumberContext(sal_uInt16 nPrefix,
    2696             :     const OUString &rLocalName,
    2697             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2698             : {
    2699           0 :     return new SmXMLNumberContext_Impl(*this,nPrefix,rLocalName);
    2700             : }
    2701             : 
    2702           0 : SvXMLImportContext *SmXMLImport::CreateIdentifierContext(sal_uInt16 nPrefix,
    2703             :     const OUString &rLocalName,
    2704             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2705             : {
    2706           0 :     return new SmXMLIdentifierContext_Impl(*this,nPrefix,rLocalName);
    2707             : }
    2708             : 
    2709           0 : SvXMLImportContext *SmXMLImport::CreateOperatorContext(sal_uInt16 nPrefix,
    2710             :     const OUString &rLocalName,
    2711             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2712             : {
    2713           0 :     return new SmXMLOperatorContext_Impl(*this,nPrefix,rLocalName);
    2714             : }
    2715             : 
    2716           0 : SvXMLImportContext *SmXMLImport::CreateSpaceContext(sal_uInt16 nPrefix,
    2717             :     const OUString &rLocalName,
    2718             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2719             : {
    2720           0 :     return new SmXMLSpaceContext_Impl(*this,nPrefix,rLocalName);
    2721             : }
    2722             : 
    2723             : 
    2724           0 : SvXMLImportContext *SmXMLImport::CreateFracContext(sal_uInt16 nPrefix,
    2725             :     const OUString &rLocalName,
    2726             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2727             : {
    2728           0 :     return new SmXMLFracContext_Impl(*this,nPrefix,rLocalName);
    2729             : }
    2730             : 
    2731           0 : SvXMLImportContext *SmXMLImport::CreateSqrtContext(sal_uInt16 nPrefix,
    2732             :     const OUString &rLocalName,
    2733             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2734             : {
    2735           0 :     return new SmXMLSqrtContext_Impl(*this,nPrefix,rLocalName);
    2736             : }
    2737             : 
    2738           0 : SvXMLImportContext *SmXMLImport::CreateRootContext(sal_uInt16 nPrefix,
    2739             :     const OUString &rLocalName,
    2740             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2741             : {
    2742           0 :     return new SmXMLRootContext_Impl(*this,nPrefix,rLocalName);
    2743             : }
    2744             : 
    2745           0 : SvXMLImportContext *SmXMLImport::CreateStyleContext(sal_uInt16 nPrefix,
    2746             :     const OUString &rLocalName,
    2747             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2748             : {
    2749           0 :     return new SmXMLStyleContext_Impl(*this,nPrefix,rLocalName);
    2750             : }
    2751             : 
    2752           0 : SvXMLImportContext *SmXMLImport::CreatePaddedContext(sal_uInt16 nPrefix,
    2753             :     const OUString &rLocalName,
    2754             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2755             : {
    2756           0 :     return new SmXMLPaddedContext_Impl(*this,nPrefix,rLocalName);
    2757             : }
    2758             : 
    2759           0 : SvXMLImportContext *SmXMLImport::CreatePhantomContext(sal_uInt16 nPrefix,
    2760             :     const OUString &rLocalName,
    2761             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2762             : {
    2763           0 :     return new SmXMLPhantomContext_Impl(*this,nPrefix,rLocalName);
    2764             : }
    2765             : 
    2766           0 : SvXMLImportContext *SmXMLImport::CreateFencedContext(sal_uInt16 nPrefix,
    2767             :     const OUString &rLocalName,
    2768             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2769             : {
    2770           0 :     return new SmXMLFencedContext_Impl(*this,nPrefix,rLocalName);
    2771             : }
    2772             : 
    2773           0 : SvXMLImportContext *SmXMLImport::CreateErrorContext(sal_uInt16 nPrefix,
    2774             :     const OUString &rLocalName,
    2775             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2776             : {
    2777           0 :     return new SmXMLErrorContext_Impl(*this,nPrefix,rLocalName);
    2778             : }
    2779             : 
    2780           0 : SvXMLImportContext *SmXMLImport::CreateSubContext(sal_uInt16 nPrefix,
    2781             :     const OUString &rLocalName,
    2782             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2783             : {
    2784           0 :     return new SmXMLSubContext_Impl(*this,nPrefix,rLocalName);
    2785             : }
    2786             : 
    2787           0 : SvXMLImportContext *SmXMLImport::CreateSubSupContext(sal_uInt16 nPrefix,
    2788             :     const OUString &rLocalName,
    2789             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2790             : {
    2791           0 :     return new SmXMLSubSupContext_Impl(*this,nPrefix,rLocalName);
    2792             : }
    2793             : 
    2794           0 : SvXMLImportContext *SmXMLImport::CreateSupContext(sal_uInt16 nPrefix,
    2795             :     const OUString &rLocalName,
    2796             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2797             : {
    2798           0 :     return new SmXMLSupContext_Impl(*this,nPrefix,rLocalName);
    2799             : }
    2800             : 
    2801           0 : SvXMLImportContext *SmXMLImport::CreateUnderContext(sal_uInt16 nPrefix,
    2802             :     const OUString &rLocalName,
    2803             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2804             : {
    2805           0 :         return new SmXMLUnderContext_Impl(*this,nPrefix,rLocalName);
    2806             : }
    2807             : 
    2808           0 : SvXMLImportContext *SmXMLImport::CreateOverContext(sal_uInt16 nPrefix,
    2809             :     const OUString &rLocalName,
    2810             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2811             : {
    2812           0 :     return new SmXMLOverContext_Impl(*this,nPrefix,rLocalName);
    2813             : }
    2814             : 
    2815           0 : SvXMLImportContext *SmXMLImport::CreateUnderOverContext(sal_uInt16 nPrefix,
    2816             :     const OUString &rLocalName,
    2817             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2818             : {
    2819           0 :     return new SmXMLUnderOverContext_Impl(*this,nPrefix,rLocalName);
    2820             : }
    2821             : 
    2822           0 : SvXMLImportContext *SmXMLImport::CreateMultiScriptsContext(sal_uInt16 nPrefix,
    2823             :     const OUString &rLocalName,
    2824             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2825             : {
    2826           0 :     return new SmXMLMultiScriptsContext_Impl(*this,nPrefix,rLocalName);
    2827             : }
    2828             : 
    2829           0 : SvXMLImportContext *SmXMLImport::CreateTableContext(sal_uInt16 nPrefix,
    2830             :     const OUString &rLocalName,
    2831             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2832             : {
    2833           0 :     return new SmXMLTableContext_Impl(*this,nPrefix,rLocalName);
    2834             : }
    2835           0 : SvXMLImportContext *SmXMLImport::CreateTableRowContext(sal_uInt16 nPrefix,
    2836             :     const OUString &rLocalName,
    2837             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2838             : {
    2839           0 :     return new SmXMLTableRowContext_Impl(*this,nPrefix,rLocalName);
    2840             : }
    2841           0 : SvXMLImportContext *SmXMLImport::CreateTableCellContext(sal_uInt16 nPrefix,
    2842             :     const OUString &rLocalName,
    2843             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2844             : {
    2845           0 :     return new SmXMLTableCellContext_Impl(*this,nPrefix,rLocalName);
    2846             : }
    2847             : 
    2848           0 : SvXMLImportContext *SmXMLImport::CreateNoneContext(sal_uInt16 nPrefix,
    2849             :     const OUString &rLocalName,
    2850             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2851             : {
    2852           0 :     return new SmXMLNoneContext_Impl(*this,nPrefix,rLocalName);
    2853             : }
    2854             : 
    2855           0 : SvXMLImportContext *SmXMLImport::CreatePrescriptsContext(sal_uInt16 nPrefix,
    2856             :     const OUString &rLocalName,
    2857             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2858             : {
    2859           0 :     return new SmXMLPrescriptsContext_Impl(*this,nPrefix,rLocalName);
    2860             : }
    2861             : 
    2862           0 : SvXMLImportContext *SmXMLImport::CreateAlignGroupContext(sal_uInt16 nPrefix,
    2863             :     const OUString &rLocalName,
    2864             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2865             : {
    2866           0 :     return new SmXMLAlignGroupContext_Impl(*this,nPrefix,rLocalName);
    2867             : }
    2868             : 
    2869           0 : SvXMLImportContext *SmXMLImport::CreateActionContext(sal_uInt16 nPrefix,
    2870             :     const OUString &rLocalName,
    2871             :     const uno::Reference <xml::sax::XAttributeList> & /*xAttrList*/)
    2872             : {
    2873           0 :     return new SmXMLActionContext_Impl(*this,nPrefix,rLocalName);
    2874             : }
    2875             : 
    2876           0 : SmXMLImport::~SmXMLImport() throw ()
    2877             : {
    2878           0 :     delete pPresLayoutElemTokenMap;
    2879           0 :     delete pPresElemTokenMap;
    2880           0 :     delete pPresScriptEmptyElemTokenMap;
    2881           0 :     delete pPresTableElemTokenMap;
    2882           0 :     delete pPresLayoutAttrTokenMap;
    2883           0 :     delete pFencedAttrTokenMap;
    2884           0 :     delete pColorTokenMap;
    2885           0 :     delete pOperatorAttrTokenMap;
    2886           0 :     delete pAnnotationAttrTokenMap;
    2887           0 : }
    2888             : 
    2889           0 : void SmXMLImport::SetViewSettings(const Sequence<PropertyValue>& aViewProps)
    2890             : {
    2891           0 :     uno::Reference <frame::XModel> xModel = GetModel();
    2892           0 :     if ( !xModel.is() )
    2893             :         return;
    2894             : 
    2895           0 :     uno::Reference <lang::XUnoTunnel> xTunnel;
    2896           0 :     xTunnel = uno::Reference <lang::XUnoTunnel> (xModel,uno::UNO_QUERY);
    2897             :     SmModel *pModel = reinterpret_cast<SmModel *>
    2898           0 :         (xTunnel->getSomething(SmModel::getUnoTunnelId()));
    2899             : 
    2900           0 :     if ( !pModel )
    2901             :         return;
    2902             : 
    2903             :     SmDocShell *pDocShell =
    2904           0 :         static_cast<SmDocShell*>(pModel->GetObjectShell());
    2905           0 :     if ( !pDocShell )
    2906             :         return;
    2907             : 
    2908           0 :     Rectangle aRect( pDocShell->GetVisArea() );
    2909             : 
    2910           0 :     sal_Int32 nCount = aViewProps.getLength();
    2911           0 :     const PropertyValue *pValue = aViewProps.getConstArray();
    2912             : 
    2913           0 :     long nTmp = 0;
    2914             : 
    2915           0 :     for (sal_Int32 i = 0; i < nCount ; i++)
    2916             :     {
    2917           0 :         if (pValue->Name == "ViewAreaTop" )
    2918             :         {
    2919           0 :             pValue->Value >>= nTmp;
    2920           0 :             aRect.setY( nTmp );
    2921             :         }
    2922           0 :         else if (pValue->Name == "ViewAreaLeft" )
    2923             :         {
    2924           0 :             pValue->Value >>= nTmp;
    2925           0 :             aRect.setX( nTmp );
    2926             :         }
    2927           0 :         else if (pValue->Name == "ViewAreaWidth" )
    2928             :         {
    2929           0 :             pValue->Value >>= nTmp;
    2930           0 :             Size aSize( aRect.GetSize() );
    2931           0 :             aSize.Width() = nTmp;
    2932           0 :             aRect.SetSize( aSize );
    2933             :         }
    2934           0 :         else if (pValue->Name == "ViewAreaHeight" )
    2935             :         {
    2936           0 :             pValue->Value >>= nTmp;
    2937           0 :             Size aSize( aRect.GetSize() );
    2938           0 :             aSize.Height() = nTmp;
    2939           0 :             aRect.SetSize( aSize );
    2940             :         }
    2941           0 :         pValue++;
    2942             :     }
    2943             : 
    2944           0 :     pDocShell->SetVisArea ( aRect );
    2945             : }
    2946             : 
    2947           0 : void SmXMLImport::SetConfigurationSettings(const Sequence<PropertyValue>& aConfProps)
    2948             : {
    2949           0 :     uno::Reference < XPropertySet > xProps ( GetModel(), UNO_QUERY );
    2950           0 :     if ( xProps.is() )
    2951             :     {
    2952           0 :         Reference < XPropertySetInfo > xInfo ( xProps->getPropertySetInfo() );
    2953           0 :         if (xInfo.is() )
    2954             :         {
    2955           0 :             sal_Int32 nCount = aConfProps.getLength();
    2956           0 :             const PropertyValue* pValues = aConfProps.getConstArray();
    2957             : 
    2958           0 :             const OUString sFormula ( "Formula" );
    2959           0 :             const OUString sBasicLibraries ( "BasicLibraries" );
    2960           0 :             const OUString sDialogLibraries ( "DialogLibraries" );
    2961           0 :             while ( nCount-- )
    2962             :             {
    2963           0 :                 if (pValues->Name != sFormula &&
    2964           0 :                     pValues->Name != sBasicLibraries &&
    2965           0 :                     pValues->Name != sDialogLibraries)
    2966             :                 {
    2967             :                     try
    2968             :                     {
    2969           0 :                         if ( xInfo->hasPropertyByName( pValues->Name ) )
    2970           0 :                             xProps->setPropertyValue( pValues->Name, pValues->Value );
    2971             :                     }
    2972           0 :                     catch (const beans::PropertyVetoException &)
    2973             :                     {
    2974             :                         // dealing with read-only properties here. Nothing to do...
    2975             :                     }
    2976           0 :                     catch( Exception& )
    2977             :                     {
    2978             :                         OSL_FAIL( "SmXMLImport::SetConfigurationSettings: Exception!" );
    2979             :                     }
    2980             :                 }
    2981             : 
    2982           0 :                 pValues++;
    2983           0 :             }
    2984           0 :         }
    2985           0 :     }
    2986          12 : }
    2987             : 
    2988             : 
    2989             : ////////////////////////////////////////////////////////////
    2990             : 
    2991             : 
    2992             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10