?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 5.2.6.1, tag libreoffice-5.2.6.1
[LibreOffice.git] / xmloff / source / core / DocumentSettingsContext.cxx
blob38f8e4f3c6112172308a9300f220260be73d7436
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <sal/config.h>
21
22 #include <officecfg/Office/Common.hxx>
23 #include <sax/tools/converter.hxx>
24
25 #include <com/sun/star/util/PathSubstitution.hpp>
26 #include <com/sun/star/util/XStringSubstitution.hpp>
27 #include <xmloff/DocumentSettingsContext.hxx>
28 #include <xmloff/xmlimp.hxx>
29 #include <xmloff/xmltoken.hxx>
30 #include <xmloff/xmlnmspe.hxx>
31 #include <xmloff/nmspmap.hxx>
32 #include <xmloff/xmluconv.hxx>
33 #include <comphelper/processfactory.hxx>
34
35 #include <list>
36 #include <com/sun/star/i18n/XForbiddenCharacters.hpp>
37 #include <com/sun/star/container/XIndexContainer.hpp>
38 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
39 #include <com/sun/star/formula/SymbolDescriptor.hpp>
40 #include <com/sun/star/util/DateTime.hpp>
41 #include <com/sun/star/document/XViewDataSupplier.hpp>
42 #include <com/sun/star/document/PrinterIndependentLayout.hpp>
43 #include <com/sun/star/document/IndexedPropertyValues.hpp>
44 #include <com/sun/star/document/NamedPropertyValues.hpp>
45 #include <rtl/ustrbuf.hxx>
46 #include <osl/diagnose.h>
47 #include <xmlenums.hxx>
48
49 using namespace com::sun::star;
50 using namespace ::xmloff::token;
51
52 class XMLMyList
53 {
54 std::list<beans::PropertyValue> aProps;
55 sal_uInt32 nCount;
56
57 css::uno::Reference< css::uno::XComponentContext > m_xContext;
58
59 public:
60 explicit XMLMyList(const uno::Reference<uno::XComponentContext>& rxContext);
61
62 void push_back(beans::PropertyValue& aProp) { aProps.push_back(aProp); nCount++; }
63 uno::Sequence<beans::PropertyValue> GetSequence();
64 uno::Reference<container::XNameContainer> GetNameContainer();
65 uno::Reference<container::XIndexContainer> GetIndexContainer();
66 };
67
68 XMLMyList::XMLMyList(const uno::Reference<uno::XComponentContext>& rxContext)
69 : nCount(0),
70 m_xContext(rxContext)
71 {
72 assert(m_xContext.is());
73 }
74
75 uno::Sequence<beans::PropertyValue> XMLMyList::GetSequence()
76 {
77 uno::Sequence<beans::PropertyValue> aSeq;
78 if(nCount)
79 {
80 assert(nCount == aProps.size());
81 aSeq.realloc(nCount);
82 beans::PropertyValue* pProps = aSeq.getArray();
83 std::list<beans::PropertyValue>::iterator aItr = aProps.begin();
84 while (aItr != aProps.end())
85 {
86 *pProps = *aItr;
87 ++pProps;
88 ++aItr;
89 }
90 }
91 return aSeq;
92 }
93
94 uno::Reference<container::XNameContainer> XMLMyList::GetNameContainer()
95 {
96 uno::Reference<container::XNameContainer> xNameContainer = document::NamedPropertyValues::create(m_xContext);
97 std::list<beans::PropertyValue>::iterator aItr = aProps.begin();
98 while (aItr != aProps.end())
99 {
100 xNameContainer->insertByName(aItr->Name, aItr->Value);
101 ++aItr;
102 }
103
104 return xNameContainer;
105 }
106
107 uno::Reference<container::XIndexContainer> XMLMyList::GetIndexContainer()
108 {
109 uno::Reference<container::XIndexContainer> xIndexContainer = document::IndexedPropertyValues::create(m_xContext);
110 std::list<beans::PropertyValue>::iterator aItr = aProps.begin();
111 sal_uInt32 i(0);
112 while (aItr != aProps.end())
113 {
114 xIndexContainer->insertByIndex(i, aItr->Value);
115 ++aItr;
116 ++i;
117 }
118
119 return xIndexContainer;
120 }
121
122 class XMLConfigBaseContext : public SvXMLImportContext
123 {
124 protected:
125 XMLMyList maProps;
126 beans::PropertyValue maProp;
127 css::uno::Any& mrAny;
128 XMLConfigBaseContext* mpBaseContext;
129 public:
130 XMLConfigBaseContext(SvXMLImport& rImport, sal_uInt16 nPrfx, const OUString& rLName,
131 css::uno::Any& rAny,
132 XMLConfigBaseContext* pBaseContext);
133 virtual ~XMLConfigBaseContext();
134
135 void AddPropertyValue() { maProps.push_back(maProp); }
136 };
137
138 class XMLConfigItemContext : public SvXMLImportContext
139 {
140 OUString msType;
141 OUString msValue;
142 uno::Sequence<sal_Int8> maDecoded;
143 css::uno::Any& mrAny;
144 const OUString mrItemName;
145 XMLConfigBaseContext* mpBaseContext;
146
147 public:
148 XMLConfigItemContext(SvXMLImport& rImport, sal_uInt16 nPrfx, const OUString& rLName,
149 const css::uno::Reference< css::xml::sax::XAttributeList>& xAttrList,
150 css::uno::Any& rAny,
151 const OUString& rItemName,
152 XMLConfigBaseContext* pBaseContext);
153 virtual ~XMLConfigItemContext();
154
155 virtual SvXMLImportContext *CreateChildContext( sal_uInt16 nPrefix,
156 const OUString& rLocalName,
157 const css::uno::Reference< css::xml::sax::XAttributeList>& xAttrList ) override;
158 virtual void Characters( const OUString& rChars ) override;
159
160 virtual void EndElement() override;
161
162 void ManipulateConfigItem();
163 };
164
165 class XMLConfigItemSetContext : public XMLConfigBaseContext
166 {
167 public:
168 XMLConfigItemSetContext(SvXMLImport& rImport, sal_uInt16 nPrfx, const OUString& rLName,
169 const css::uno::Reference< css::xml::sax::XAttributeList>& xAttrList,
170 css::uno::Any& rAny,
171 XMLConfigBaseContext* pBaseContext);
172 virtual ~XMLConfigItemSetContext();
173
174 virtual SvXMLImportContext *CreateChildContext( sal_uInt16 nPrefix,
175 const OUString& rLocalName,
176 const css::uno::Reference< css::xml::sax::XAttributeList>& xAttrList ) override;
177
178 virtual void EndElement() override;
179 };
180
181 class XMLConfigItemMapNamedContext : public XMLConfigBaseContext
182 {
183 public:
184 XMLConfigItemMapNamedContext(SvXMLImport& rImport, sal_uInt16 nPrfx, const OUString& rLName,
185 const css::uno::Reference< css::xml::sax::XAttributeList>& xAttrList,
186 css::uno::Any& rAny,
187 XMLConfigBaseContext* pBaseContext);
188 virtual ~XMLConfigItemMapNamedContext();
189
190 virtual SvXMLImportContext *CreateChildContext( sal_uInt16 nPrefix,
191 const OUString& rLocalName,
192 const css::uno::Reference< css::xml::sax::XAttributeList>& xAttrList ) override;
193
194 virtual void EndElement() override;
195 };
196
197 class XMLConfigItemMapIndexedContext : public XMLConfigBaseContext
198 {
199 private:
200 OUString maConfigItemName;
201
202 public:
203 XMLConfigItemMapIndexedContext(SvXMLImport& rImport, sal_uInt16 nPrfx,
204 const OUString& rLName,
205 const css::uno::Reference< css::xml::sax::XAttributeList>& xAttrList,
206 css::uno::Any& rAny,
207 const OUString& rConfigItemName,
208 XMLConfigBaseContext* pBaseContext);
209 virtual ~XMLConfigItemMapIndexedContext();
210
211 virtual SvXMLImportContext *CreateChildContext( sal_uInt16 nPrefix,
212 const OUString& rLocalName,
213 const css::uno::Reference< css::xml::sax::XAttributeList>& xAttrList ) override;
214
215 virtual void EndElement() override;
216 };
217
218 SvXMLImportContext *CreateSettingsContext(SvXMLImport& rImport, sal_uInt16 p_nPrefix,
219 const OUString& rLocalName,
220 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
221 beans::PropertyValue& rProp, XMLConfigBaseContext* pBaseContext)
222 {
223 SvXMLImportContext *pContext = nullptr;
224
225 rProp.Name.clear();
226 sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
227 for( sal_Int16 i=0; i < nAttrCount; i++ )
228 {
229 OUString sAttrName = xAttrList->getNameByIndex( i );
230 OUString aLocalName;
231 sal_uInt16 nPrefix = rImport.GetNamespaceMap().GetKeyByAttrName(
232 sAttrName, &aLocalName );
233 OUString sValue = xAttrList->getValueByIndex( i );
234
235 if (nPrefix == XML_NAMESPACE_CONFIG)
236 {
237 if (IsXMLToken(aLocalName, XML_NAME))
238 rProp.Name = sValue;
239 }
240 }
241
242 if (p_nPrefix == XML_NAMESPACE_CONFIG)
243 {
244 if (IsXMLToken(rLocalName, XML_CONFIG_ITEM))
245 pContext = new XMLConfigItemContext(rImport, p_nPrefix, rLocalName, xAttrList, rProp.Value, rProp.Name, pBaseContext);
246 else if((IsXMLToken(rLocalName, XML_CONFIG_ITEM_SET)) ||
247 (IsXMLToken(rLocalName, XML_CONFIG_ITEM_MAP_ENTRY)) )
248 pContext = new XMLConfigItemSetContext(rImport, p_nPrefix, rLocalName, xAttrList, rProp.Value, pBaseContext);
249 else if(IsXMLToken(rLocalName, XML_CONFIG_ITEM_MAP_NAMED))
250 pContext = new XMLConfigItemMapNamedContext(rImport, p_nPrefix, rLocalName, xAttrList, rProp.Value, pBaseContext);
251 else if(IsXMLToken(rLocalName, XML_CONFIG_ITEM_MAP_INDEXED))
252 pContext = new XMLConfigItemMapIndexedContext(rImport, p_nPrefix, rLocalName, xAttrList, rProp.Value, rProp.Name, pBaseContext);
253 }
254
255 if( !pContext )
256 pContext = new SvXMLImportContext( rImport, p_nPrefix, rLocalName );
257
258 return pContext;
259 }
260
261 namespace
262 {
263 struct SettingsGroup
264 {
265 OUString sGroupName;
266 uno::Any aSettings;
267
268 SettingsGroup( const OUString& _rGroupName, const uno::Any& _rSettings )
269 :sGroupName( _rGroupName )
270 ,aSettings( _rSettings )
271 {
272 }
273 };
274 }
275
276 struct XMLDocumentSettingsContext_Data
277 {
278 css::uno::Any aViewProps;
279 css::uno::Any aConfigProps;
280 ::std::list< SettingsGroup > aDocSpecificSettings;
281 };
282
283 XMLDocumentSettingsContext::XMLDocumentSettingsContext(SvXMLImport& rImport, sal_uInt16 nPrfx, const OUString& rLName,
284 const uno::Reference<xml::sax::XAttributeList>& )
285 : SvXMLImportContext( rImport, nPrfx, rLName )
286 , m_pData( new XMLDocumentSettingsContext_Data )
287 {
288 // here are no attributes
289 }
290
291 XMLDocumentSettingsContext::~XMLDocumentSettingsContext()
292 {
293 }
294
295 SvXMLImportContext *XMLDocumentSettingsContext::CreateChildContext( sal_uInt16 p_nPrefix,
296 const OUString& rLocalName,
297 const css::uno::Reference< css::xml::sax::XAttributeList>& xAttrList )
298 {
299 SvXMLImportContext *pContext = nullptr;
300 OUString sName;
301
302 sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
303 for( sal_Int16 i=0; i < nAttrCount; i++ )
304 {
305 OUString sAttrName = xAttrList->getNameByIndex( i );
306 OUString aLocalName;
307 sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName(
308 sAttrName, &aLocalName );
309 OUString sValue = xAttrList->getValueByIndex( i );
310
311 if (nPrefix == XML_NAMESPACE_CONFIG)
312 {
313 if (IsXMLToken(aLocalName, XML_NAME))
314 sName = sValue;
315 }
316 }
317
318 if (p_nPrefix == XML_NAMESPACE_CONFIG)
319 {
320 if (IsXMLToken(rLocalName, XML_CONFIG_ITEM_SET))
321 {
322 OUString aLocalConfigName;
323 sal_uInt16 nConfigPrefix =
324 GetImport().GetNamespaceMap().GetKeyByAttrName(
325 sName, &aLocalConfigName );
326
327 if( XML_NAMESPACE_OOO == nConfigPrefix )
328 {
329 if (IsXMLToken(aLocalConfigName, XML_VIEW_SETTINGS))
330 pContext = new XMLConfigItemSetContext(GetImport(),
331 p_nPrefix, rLocalName, xAttrList,
332 m_pData->aViewProps, nullptr);
333 else if (IsXMLToken(aLocalConfigName,
334 XML_CONFIGURATION_SETTINGS))
335 pContext = new XMLConfigItemSetContext(GetImport(),
336 p_nPrefix, rLocalName, xAttrList,
337 m_pData->aConfigProps, nullptr);
338 else
339 {
340 m_pData->aDocSpecificSettings.push_back( SettingsGroup( aLocalConfigName, uno::Any() ) );
341
342 ::std::list< SettingsGroup >::reverse_iterator settingsPos =
343 m_pData->aDocSpecificSettings.rbegin();
344
345 pContext = new XMLConfigItemSetContext(GetImport(),
346 p_nPrefix, rLocalName, xAttrList,
347 settingsPos->aSettings, nullptr);
348 }
349 }
350 }
351 }
352
353 if( !pContext )
354 pContext = new SvXMLImportContext( GetImport(), p_nPrefix, rLocalName );
355
356 return pContext;
357 }
358
359 void XMLDocumentSettingsContext::EndElement()
360 {
361 uno::Sequence<beans::PropertyValue> aSeqViewProps;
362 if (m_pData->aViewProps >>= aSeqViewProps)
363 {
364 GetImport().SetViewSettings(aSeqViewProps);
365 sal_Int32 i(aSeqViewProps.getLength() - 1);
366 bool bFound(false);
367 while((i >= 0) && !bFound)
368 {
369 if (aSeqViewProps[i].Name == "Views")
370 {
371 bFound = true;
372 uno::Reference<container::XIndexAccess> xIndexAccess;
373 if (aSeqViewProps[i].Value >>= xIndexAccess)
374 {
375 uno::Reference<document::XViewDataSupplier> xViewDataSupplier(GetImport().GetModel(), uno::UNO_QUERY);
376 if (xViewDataSupplier.is())
377 xViewDataSupplier->setViewData(xIndexAccess);
378 }
379 }
380 else
381 i--;
382 }
383 }
384
385 uno::Sequence<beans::PropertyValue> aSeqConfigProps;
386 if ( m_pData->aConfigProps >>= aSeqConfigProps )
387 {
388 if (!officecfg::Office::Common::Save::Document::LoadPrinter::get())
389 {
390 sal_Int32 i = aSeqConfigProps.getLength() - 1;
391 int nFound = 0;
392
393 while ( ( i >= 0 ) && nFound < 2 )
394 {
395 OUString sProp( aSeqConfigProps[i].Name );
396
397 if ( sProp == "PrinterName" )
398 {
399 aSeqConfigProps[i].Value = uno::makeAny( OUString() );
400 nFound++;
401 }
402 else if ( sProp == "PrinterSetup" )
403 {
404 uno::Sequence< sal_Int8 > aEmpty;
405 aSeqConfigProps[i].Value = uno::makeAny( aEmpty );
406 nFound++;
407 }
408
409 i--;
410 }
411 }
412
413 GetImport().SetConfigurationSettings( aSeqConfigProps );
414 }
415
416 for ( ::std::list< SettingsGroup >::const_iterator settings = m_pData->aDocSpecificSettings.begin();
417 settings != m_pData->aDocSpecificSettings.end();
418 ++settings
419 )
420 {
421 uno::Sequence< beans::PropertyValue > aDocSettings;
422 OSL_VERIFY( settings->aSettings >>= aDocSettings );
423 GetImport().SetDocumentSpecificSettings( settings->sGroupName, aDocSettings );
424 }
425 }
426
427 XMLConfigBaseContext::XMLConfigBaseContext(SvXMLImport& rImport, sal_uInt16 nPrfx,
428 const OUString& rLName, css::uno::Any& rTempAny,
429 XMLConfigBaseContext* pTempBaseContext)
430 : SvXMLImportContext( rImport, nPrfx, rLName ),
431 maProps( rImport.GetComponentContext() ),
432 maProp(),
433 mrAny(rTempAny),
434 mpBaseContext(pTempBaseContext)
435 {
436 }
437
438 XMLConfigBaseContext::~XMLConfigBaseContext()
439 {
440 }
441
442 XMLConfigItemSetContext::XMLConfigItemSetContext(SvXMLImport& rImport, sal_uInt16 nPrfx,
443 const OUString& rLName,
444 const css::uno::Reference< css::xml::sax::XAttributeList>&,
445 css::uno::Any& rAny,
446 XMLConfigBaseContext* pBaseContext)
447 : XMLConfigBaseContext( rImport, nPrfx, rLName, rAny, pBaseContext )
448 {
449 // here are no attributes
450 }
451
452 XMLConfigItemSetContext::~XMLConfigItemSetContext()
453 {
454 }
455
456 SvXMLImportContext *XMLConfigItemSetContext::CreateChildContext( sal_uInt16 nPrefix,
457 const OUString& rLocalName,
458 const css::uno::Reference< css::xml::sax::XAttributeList>& xAttrList )
459 {
460 return CreateSettingsContext(GetImport(), nPrefix, rLocalName, xAttrList, maProp, this);
461 }
462
463 void XMLConfigItemSetContext::EndElement()
464 {
465 mrAny <<= maProps.GetSequence();
466 if (mpBaseContext)
467 mpBaseContext->AddPropertyValue();
468 }
469
470 XMLConfigItemContext::XMLConfigItemContext(SvXMLImport& rImport, sal_uInt16 nPrfx, const OUString& rLName,
471 const css::uno::Reference< css::xml::sax::XAttributeList>& xAttrList,
472 css::uno::Any& rTempAny,
473 const OUString& rTempItemName,
474 XMLConfigBaseContext* pTempBaseContext)
475 : SvXMLImportContext(rImport, nPrfx, rLName),
476 mrAny(rTempAny),
477 mrItemName(rTempItemName),
478 mpBaseContext(pTempBaseContext)
479 {
480 sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
481 for( sal_Int16 i=0; i < nAttrCount; i++ )
482 {
483 OUString sAttrName = xAttrList->getNameByIndex( i );
484 OUString aLocalName;
485 sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName(
486 sAttrName, &aLocalName );
487 OUString sValue = xAttrList->getValueByIndex( i );
488
489 if (nPrefix == XML_NAMESPACE_CONFIG)
490 {
491 if (IsXMLToken(aLocalName, XML_TYPE))
492 msType = sValue;
493 }
494 }
495 }
496
497 XMLConfigItemContext::~XMLConfigItemContext()
498 {
499 }
500
501 SvXMLImportContext *XMLConfigItemContext::CreateChildContext( sal_uInt16 nPrefix,
502 const OUString& rLocalName,
503 const css::uno::Reference< css::xml::sax::XAttributeList>& )
504 {
505 SvXMLImportContext* pContext = new SvXMLImportContext(GetImport(), nPrefix, rLocalName);
506 return pContext;
507 }
508
509 void XMLConfigItemContext::Characters( const OUString& rChars )
510 {
511 if (IsXMLToken(msType, XML_BASE64BINARY))
512 {
513 OUString sTrimmedChars( rChars.trim() );
514 if( !sTrimmedChars.isEmpty() )
515 {
516 OUString sChars;
517 if( !msValue.isEmpty() )
518 {
519 sChars = msValue;
520 sChars += sTrimmedChars;
521 msValue.clear();
522 }
523 else
524 {
525 sChars = sTrimmedChars;
526 }
527 uno::Sequence<sal_Int8> aBuffer((sChars.getLength() / 4) * 3 );
528 sal_Int32 const nCharsDecoded =
529 ::sax::Converter::decodeBase64SomeChars( aBuffer, sChars );
530 sal_uInt32 nStartPos(maDecoded.getLength());
531 sal_uInt32 nCount(aBuffer.getLength());
532 maDecoded.realloc(nStartPos + nCount);
533 sal_Int8* pDecoded = maDecoded.getArray();
534 sal_Int8* pBuffer = aBuffer.getArray();
535 for (sal_uInt32 i = 0; i < nCount; i++, pBuffer++)
536 pDecoded[nStartPos + i] = *pBuffer;
537 if( nCharsDecoded != sChars.getLength() )
538 msValue = sChars.copy( nCharsDecoded );
539 }
540 }
541 else
542 msValue += rChars;
543 }
544
545 void XMLConfigItemContext::EndElement()
546 {
547 if (mpBaseContext)
548 {
549 if (IsXMLToken(msType, XML_BOOLEAN))
550 {
551 bool bValue(false);
552 if (IsXMLToken(msValue, XML_TRUE))
553 bValue = true;
554 mrAny <<= bValue;
555 }
556 else if (IsXMLToken(msType, XML_BYTE))
557 {
558 sal_Int32 nValue(0);
559 ::sax::Converter::convertNumber(nValue, msValue);
560 mrAny <<= static_cast<sal_Int8>(nValue);
561 }
562 else if (IsXMLToken(msType, XML_SHORT))
563 {
564 sal_Int32 nValue(0);
565 ::sax::Converter::convertNumber(nValue, msValue);
566 mrAny <<= static_cast<sal_Int16>(nValue);
567 }
568 else if (IsXMLToken(msType, XML_INT))
569 {
570 sal_Int32 nValue(0);
571 ::sax::Converter::convertNumber(nValue, msValue);
572 mrAny <<= nValue;
573 }
574 else if (IsXMLToken(msType, XML_LONG))
575 {
576 sal_Int64 nValue(msValue.toInt64());
577 mrAny <<= nValue;
578 }
579 else if (IsXMLToken(msType, XML_DOUBLE))
580 {
581 double fValue(0.0);
582 ::sax::Converter::convertDouble(fValue, msValue);
583 mrAny <<= fValue;
584 }
585 else if (IsXMLToken(msType, XML_STRING))
586 {
587 mrAny <<= msValue;
588 }
589 else if (IsXMLToken(msType, XML_DATETIME))
590 {
591 util::DateTime aDateTime;
592 ::sax::Converter::parseDateTime(aDateTime, nullptr, msValue);
593 mrAny <<= aDateTime;
594 }
595 else if (IsXMLToken(msType, XML_BASE64BINARY))
596 {
597 mrAny <<= maDecoded;
598 }
599 else {
600 SAL_INFO("xmloff.core",
601 "XMLConfigItemContext: unknown type: " << msType);
602 }
603
604 ManipulateConfigItem();
605
606 mpBaseContext->AddPropertyValue();
607 }
608 else {
609 assert(false && "no BaseContext");
610 }
611 }
612
613 /** There are some instances where there is a mismatch between API and
614 * XML mapping of a setting. In this case, this method allows us to
615 * manipulate the values accordingly. */
616 void XMLConfigItemContext::ManipulateConfigItem()
617 {
618 if( mrItemName == "PrinterIndependentLayout" )
619 {
620 OUString sValue;
621 mrAny >>= sValue;
622
623 sal_Int16 nTmp = document::PrinterIndependentLayout::HIGH_RESOLUTION;
624
625 if( sValue == "enabled" || sValue == "low-resolution" )
626 {
627 nTmp = document::PrinterIndependentLayout::LOW_RESOLUTION;
628 }
629 else if ( sValue == "disabled" )
630 {
631 nTmp = document::PrinterIndependentLayout::DISABLED;
632 }
633 // else: default to high_resolution
634
635 mrAny <<= nTmp;
636 }
637 else if( (mrItemName == "ColorTableURL") || (mrItemName == "LineEndTableURL") || (mrItemName == "HatchTableURL")
638 || (mrItemName == "DashTableURL") || (mrItemName == "GradientTableURL") || (mrItemName == "BitmapTableURL") )
639 {
640 try
641 {
642 uno::Reference< uno::XComponentContext > xContext( GetImport().GetComponentContext() );
643 uno::Reference< util::XStringSubstitution > xStringSubsitution( util::PathSubstitution::create(xContext) );
644
645 OUString aURL;
646 mrAny >>= aURL;
647 aURL = xStringSubsitution->substituteVariables( aURL, false );
648 mrAny <<= aURL;
649 }
650 catch( uno::Exception& )
651 {
652 }
653 }
654 }
655
656 XMLConfigItemMapNamedContext::XMLConfigItemMapNamedContext(SvXMLImport& rImport, sal_uInt16 nPrfx, const OUString& rLName,
657 const css::uno::Reference< css::xml::sax::XAttributeList>&,
658 css::uno::Any& rAny,
659 XMLConfigBaseContext* pBaseContext)
660 : XMLConfigBaseContext(rImport, nPrfx, rLName, rAny, pBaseContext)
661 {
662 }
663
664 XMLConfigItemMapNamedContext::~XMLConfigItemMapNamedContext()
665 {
666 }
667
668 SvXMLImportContext *XMLConfigItemMapNamedContext::CreateChildContext( sal_uInt16 nPrefix,
669 const OUString& rLocalName,
670 const css::uno::Reference< css::xml::sax::XAttributeList>& xAttrList )
671 {
672 return CreateSettingsContext(GetImport(), nPrefix, rLocalName, xAttrList, maProp, this);
673 }
674
675 void XMLConfigItemMapNamedContext::EndElement()
676 {
677 if (mpBaseContext)
678 {
679 mrAny <<= maProps.GetNameContainer();
680 mpBaseContext->AddPropertyValue();
681 }
682 else {
683 assert(false && "no BaseContext");
684 }
685 }
686
687 XMLConfigItemMapIndexedContext::XMLConfigItemMapIndexedContext(SvXMLImport& rImport, sal_uInt16 nPrfx,
688 const OUString& rLName,
689 const css::uno::Reference< css::xml::sax::XAttributeList>&,
690 css::uno::Any& rAny,
691 const OUString& rConfigItemName,
692 XMLConfigBaseContext* pBaseContext)
693 : XMLConfigBaseContext(rImport, nPrfx, rLName, rAny, pBaseContext),
694 maConfigItemName( rConfigItemName )
695 {
696 }
697
698 XMLConfigItemMapIndexedContext::~XMLConfigItemMapIndexedContext()
699 {
700 }
701
702 SvXMLImportContext *XMLConfigItemMapIndexedContext::CreateChildContext( sal_uInt16 nPrefix,
703 const OUString& rLocalName,
704 const css::uno::Reference< css::xml::sax::XAttributeList>& xAttrList )
705 {
706 return CreateSettingsContext(GetImport(), nPrefix, rLocalName, xAttrList, maProp, this);
707 }
708
709 void XMLConfigItemMapIndexedContext::EndElement()
710 {
711 if (mpBaseContext)
712 {
713 if ( maConfigItemName == "ForbiddenCharacters" )
714 {
715 uno::Reference< i18n::XForbiddenCharacters > xForbChars;
716
717 // get the forbidden characters from the document
718 uno::Reference< lang::XMultiServiceFactory > xFac( GetImport().GetModel(), uno::UNO_QUERY );
719 if( xFac.is() )
720 {
721 uno::Reference< beans::XPropertySet > xProps( xFac->createInstance( "com.sun.star.document.Settings" ), uno::UNO_QUERY );
722 if( xProps.is() && xProps->getPropertySetInfo()->hasPropertyByName( maConfigItemName ) )
723 {
724 xProps->getPropertyValue( maConfigItemName ) >>= xForbChars;
725 }
726 }
727
728 if( xForbChars.is() )
729 {
730
731 uno::Reference< container::XIndexAccess > xIndex( maProps.GetIndexContainer(), uno::UNO_QUERY );
732
733 const sal_Int32 nCount = xIndex->getCount();
734 uno::Sequence < beans::PropertyValue > aProps;
735 for (sal_Int32 i = 0; i < nCount; i++)
736 {
737 if ((xIndex->getByIndex( i ) >>= aProps) && (aProps.getLength() == XML_FORBIDDEN_CHARACTER_MAX ) )
738 {
739 /* FIXME-BCP47: this stupid and counterpart in
740 * xmloff/source/core/SettingsExportHelper.cxx
741 * XMLSettingsExportHelper::exportForbiddenCharacters()
742 * */
743
744 beans::PropertyValue *pForChar = aProps.getArray();
745 i18n::ForbiddenCharacters aForbid;
746 lang::Locale aLocale;
747 bool bHaveLanguage = false, bHaveCountry = false, bHaveVariant = false,
748 bHaveBegin = false, bHaveEnd = false;
749
750 for ( sal_Int32 j = 0 ; j < XML_FORBIDDEN_CHARACTER_MAX ; j++ )
751 {
752 if (pForChar->Name == "Language")
753 {
754 pForChar->Value >>= aLocale.Language;
755 bHaveLanguage = true;
756 }
757 else if (pForChar->Name == "Country")
758 {
759 pForChar->Value >>= aLocale.Country;
760 bHaveCountry = true;
761 }
762 else if (pForChar->Name == "Variant")
763 {
764 pForChar->Value >>= aLocale.Variant;
765 bHaveVariant = true;
766 }
767 else if (pForChar->Name == "BeginLine")
768 {
769 pForChar->Value >>= aForbid.beginLine;
770 bHaveBegin = true;
771 }
772 else if (pForChar->Name == "EndLine")
773 {
774 pForChar->Value >>= aForbid.endLine;
775 bHaveEnd = true;
776 }
777 pForChar++;
778 }
779
780 if ( bHaveLanguage && bHaveCountry && bHaveVariant && bHaveBegin && bHaveEnd )
781 {
782 try
783 {
784 xForbChars->setForbiddenCharacters( aLocale, aForbid );
785 }
786 catch (uno::Exception const& e)
787 {
788 SAL_WARN("xmloff.core",
789 "Exception while importing forbidden characters: " << e.Message);
790 }
791 }
792 }
793 }
794 }
795 else
796 {
797 SAL_WARN("xmloff.core", "could not get the XForbiddenCharacters from document!");
798 mrAny <<= maProps.GetIndexContainer();
799 }
800 }
801 else if ( maConfigItemName == "Symbols" )
802 {
803 uno::Reference< container::XIndexAccess > xIndex( maProps.GetIndexContainer(), uno::UNO_QUERY );
804
805 const sal_Int32 nCount = xIndex->getCount();
806 uno::Sequence < beans::PropertyValue > aProps;
807 uno::Sequence < formula::SymbolDescriptor > aSymbolList ( nCount );
808
809 formula::SymbolDescriptor *pDescriptor = aSymbolList.getArray();
810
811 sal_Int16 nNumFullEntries = 0;
812
813 for ( sal_Int32 i = 0; i < nCount; i++ )
814 {
815 if ((xIndex->getByIndex( i ) >>= aProps) && (aProps.getLength() == XML_SYMBOL_DESCRIPTOR_MAX ) )
816 {
817 bool bHaveName = false, bHaveExportName = false, bHaveCharSet = false,
818 bHaveFontName = false, bHaveFamily = false, bHavePitch = false,
819 bHaveWeight = false, bHaveItalic = false, bHaveSymbolSet = false,
820 bHaveCharacter = false;
821 beans::PropertyValue *pSymbol = aProps.getArray();
822
823 for ( sal_Int32 j = 0 ; j < XML_SYMBOL_DESCRIPTOR_MAX ; j++ )
824 {
825 if (pSymbol->Name == "Name")
826 {
827 pSymbol->Value >>= pDescriptor[nNumFullEntries].sName;
828 bHaveName = true;
829 }
830 else if (pSymbol->Name == "ExportName")
831 {
832 pSymbol->Value >>= pDescriptor[nNumFullEntries].sExportName;
833 bHaveExportName = true;
834 }
835 else if (pSymbol->Name == "FontName")
836 {
837 pSymbol->Value >>= pDescriptor[nNumFullEntries].sFontName;
838 bHaveFontName = true;
839 }
840 else if (pSymbol->Name == "CharSet")
841 {
842 pSymbol->Value >>= pDescriptor[nNumFullEntries].nCharSet;
843 bHaveCharSet = true;
844 }
845 else if (pSymbol->Name == "Family")
846 {
847 pSymbol->Value >>= pDescriptor[nNumFullEntries].nFamily;
848 bHaveFamily = true;
849 }
850 else if (pSymbol->Name == "Pitch")
851 {
852 pSymbol->Value >>= pDescriptor[nNumFullEntries].nPitch;
853 bHavePitch = true;
854 }
855 else if (pSymbol->Name == "Weight")
856 {
857 pSymbol->Value >>= pDescriptor[nNumFullEntries].nWeight;
858 bHaveWeight = true;
859 }
860 else if (pSymbol->Name == "Italic")
861 {
862 pSymbol->Value >>= pDescriptor[nNumFullEntries].nItalic;
863 bHaveItalic = true;
864 }
865 else if (pSymbol->Name == "SymbolSet")
866 {
867 pSymbol->Value >>= pDescriptor[nNumFullEntries].sSymbolSet;
868 bHaveSymbolSet = true;
869 }
870 else if (pSymbol->Name == "Character")
871 {
872 pSymbol->Value >>= pDescriptor[nNumFullEntries].nCharacter;
873 bHaveCharacter = true;
874 }
875 pSymbol++;
876 }
877 if ( bHaveName && bHaveExportName && bHaveCharSet && bHaveFontName && bHaveCharacter
878 && bHaveFamily && bHavePitch && bHaveWeight && bHaveItalic && bHaveSymbolSet)
879 nNumFullEntries++;
880 }
881 }
882 aSymbolList.realloc (nNumFullEntries);
883 mrAny <<= aSymbolList;
884 }
885 else
886 {
887 mrAny <<= maProps.GetIndexContainer();
888 }
889 mpBaseContext->AddPropertyValue();
890 }
891 else {
892 assert(false && "no BaseContext");
893 }
894 }
895
896 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE