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