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