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