Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <com/sun/star/util/MeasureUnit.hpp>
22 : #include <com/sun/star/packages/zip/ZipIOException.hpp>
23 : #include <com/sun/star/embed/ElementModes.hpp>
24 : #include <com/sun/star/sdb/XOfficeDatabaseDocument.hpp>
25 : #ifdef SOLAR_JAVA
26 : #include <jvmaccess/virtualmachine.hxx>
27 : #endif
28 : #include "xmlfilter.hxx"
29 : #include "flt_reghelper.hxx"
30 : #include <vcl/svapp.hxx>
31 : #include <vcl/window.hxx>
32 : #include <xmloff/xmlnmspe.hxx>
33 : #include <xmloff/xmlscripti.hxx>
34 : #include <xmloff/xmltoken.hxx>
35 : #include <xmloff/txtimp.hxx>
36 : #include <xmloff/nmspmap.hxx>
37 : #include <com/sun/star/xml/sax/InputSource.hpp>
38 : #include <com/sun/star/xml/sax/Parser.hpp>
39 : #include <xmloff/ProgressBarHelper.hxx>
40 : #include <sfx2/docfile.hxx>
41 : #include <com/sun/star/io/XInputStream.hpp>
42 : #include <com/sun/star/uno/XNamingService.hpp>
43 : #include "xmlDatabase.hxx"
44 : #include "xmlEnums.hxx"
45 : #include "xmlstrings.hrc"
46 : #include <xmloff/DocumentSettingsContext.hxx>
47 : #include "xmlStyleImport.hxx"
48 : #include <xmloff/xmluconv.hxx>
49 : #include "xmlHelper.hxx"
50 : #include <com/sun/star/util/XModifiable.hpp>
51 : #include <com/sun/star/frame/Desktop.hpp>
52 : #include <com/sun/star/frame/XComponentLoader.hpp>
53 : #include <com/sun/star/frame/FrameSearchFlag.hpp>
54 : #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
55 : #include <osl/mutex.hxx>
56 : #include <svtools/sfxecode.hxx>
57 : #include <unotools/moduleoptions.hxx>
58 : #include <toolkit/helper/vclunohelper.hxx>
59 : #include <tools/diagnose_ex.h>
60 : #include <osl/diagnose.h>
61 : #include <comphelper/processfactory.hxx>
62 : #include <comphelper/namedvaluecollection.hxx>
63 : #include <comphelper/mimeconfighelper.hxx>
64 : #include <comphelper/documentconstants.hxx>
65 : #include <comphelper/uno3.hxx>
66 : #include <cppuhelper/exc_hlp.hxx>
67 : #include <osl/thread.hxx>
68 : #include <connectivity/CommonTools.hxx>
69 : #include <connectivity/DriversConfig.hxx>
70 : #include "dsntypes.hxx"
71 : #include <rtl/strbuf.hxx>
72 :
73 : using namespace ::com::sun::star;
74 :
75 6 : extern "C" void SAL_CALL createRegistryInfo_ODBFilter( )
76 : {
77 6 : static ::dbaxml::OMultiInstanceAutoRegistration< ::dbaxml::ODBFilter > aAutoRegistration;
78 6 : }
79 : //--------------------------------------------------------------------------
80 : namespace dbaxml
81 : {
82 : namespace
83 : {
84 : class FastLoader : public ::osl::Thread
85 : {
86 : public:
87 : typedef enum { E_JAVA, E_CALC } StartType;
88 0 : FastLoader(uno::Reference< uno::XComponentContext > const & _xContext,StartType _eType)
89 : :m_xContext(_xContext)
90 0 : ,m_eWhat(_eType)
91 0 : {}
92 :
93 : protected:
94 0 : virtual ~FastLoader(){}
95 :
96 : /// Working method which should be overridden.
97 : virtual void SAL_CALL run();
98 : virtual void SAL_CALL onTerminated();
99 : private:
100 : uno::Reference< uno::XComponentContext > m_xContext;
101 : StartType m_eWhat;
102 : };
103 :
104 0 : void SAL_CALL FastLoader::run()
105 : {
106 0 : if ( m_eWhat == E_JAVA )
107 : {
108 : #ifdef SOLAR_JAVA
109 : static bool s_bFirstTime = true;
110 0 : if ( s_bFirstTime )
111 : {
112 0 : s_bFirstTime = false;
113 : try
114 : {
115 0 : ::rtl::Reference< jvmaccess::VirtualMachine > xJVM = ::connectivity::getJavaVM(m_xContext);
116 : }
117 0 : catch (const uno::Exception&)
118 : {
119 : OSL_ASSERT(0);
120 : }
121 : }
122 : #endif
123 : }
124 0 : else if ( m_eWhat == E_CALC )
125 : {
126 : static bool s_bFirstTime = true;
127 0 : if ( s_bFirstTime )
128 : {
129 0 : s_bFirstTime = false;
130 : try
131 : {
132 0 : uno::Reference<frame::XDesktop2> xDesktop = frame::Desktop::create( m_xContext );
133 0 : const OUString sTarget("_blank");
134 0 : sal_Int32 nFrameSearchFlag = frame::FrameSearchFlag::TASKS | frame::FrameSearchFlag::CREATE;
135 0 : uno::Reference< frame::XFrame> xFrame = xDesktop->findFrame(sTarget,nFrameSearchFlag);
136 0 : uno::Reference<frame::XComponentLoader> xFrameLoad(xFrame,uno::UNO_QUERY);
137 :
138 0 : if ( xFrameLoad.is() )
139 : {
140 0 : uno::Sequence < beans::PropertyValue > aArgs( 3);
141 0 : sal_Int32 nLen = 0;
142 0 : aArgs[nLen].Name = OUString("AsTemplate");
143 0 : aArgs[nLen++].Value <<= sal_False;
144 :
145 0 : aArgs[nLen].Name = OUString("ReadOnly");
146 0 : aArgs[nLen++].Value <<= sal_True;
147 :
148 0 : aArgs[nLen].Name = OUString("Hidden");
149 0 : aArgs[nLen++].Value <<= sal_True;
150 :
151 0 : ::comphelper::MimeConfigurationHelper aHelper( m_xContext );
152 0 : SvtModuleOptions aModuleOptions;
153 0 : uno::Reference< frame::XModel > xModel(xFrameLoad->loadComponentFromURL(
154 : aModuleOptions.GetFactoryEmptyDocumentURL( aModuleOptions.ClassifyFactoryByServiceName( aHelper.GetDocServiceNameFromMediaType(MIMETYPE_OASIS_OPENDOCUMENT_SPREADSHEET) )),
155 : OUString(), // empty frame name
156 : 0,
157 : aArgs
158 0 : ),uno::UNO_QUERY);
159 0 : ::comphelper::disposeComponent(xModel);
160 0 : }
161 : }
162 0 : catch (const uno::Exception&)
163 : {
164 : OSL_ASSERT(0);
165 : }
166 : }
167 : }
168 0 : }
169 0 : void SAL_CALL FastLoader::onTerminated()
170 : {
171 0 : delete this;
172 0 : }
173 :
174 : class DatasourceURLListener : public ::cppu::WeakImplHelper1< beans::XPropertyChangeListener >
175 : {
176 : uno::Reference< uno::XComponentContext > m_xContext;
177 : ::dbaccess::ODsnTypeCollection m_aTypeCollection;
178 : DatasourceURLListener(const DatasourceURLListener&);
179 : void operator =(const DatasourceURLListener&);
180 : protected:
181 18 : virtual ~DatasourceURLListener(){}
182 : public:
183 9 : DatasourceURLListener(uno::Reference< uno::XComponentContext > const & _xContext) : m_xContext(_xContext), m_aTypeCollection(_xContext){}
184 : // XPropertyChangeListener
185 9 : virtual void SAL_CALL propertyChange( const beans::PropertyChangeEvent& _rEvent ) throw (uno::RuntimeException)
186 : {
187 9 : OUString sURL;
188 9 : _rEvent.NewValue >>= sURL;
189 9 : FastLoader* pCreatorThread = NULL;
190 :
191 9 : if ( m_aTypeCollection.needsJVM(sURL) )
192 : {
193 : #ifdef SOLAR_JAVA
194 0 : pCreatorThread = new FastLoader(m_xContext, FastLoader::E_JAVA);
195 : #endif
196 : }
197 9 : else if ( sURL.matchIgnoreAsciiCaseAsciiL("sdbc:calc:",10,0) )
198 : {
199 0 : pCreatorThread = new FastLoader(m_xContext, FastLoader::E_CALC);
200 : }
201 9 : if ( pCreatorThread )
202 : {
203 0 : pCreatorThread->createSuspended();
204 0 : pCreatorThread->setPriority(osl_Thread_PriorityBelowNormal);
205 0 : pCreatorThread->resume();
206 9 : }
207 9 : }
208 : // XEventListener
209 9 : virtual void SAL_CALL disposing( const lang::EventObject& /*_rSource*/ ) throw (uno::RuntimeException)
210 : {
211 9 : }
212 : };
213 : }
214 : sal_Char const sXML_np__db[] = "_db";
215 : sal_Char const sXML_np___db[] = "__db";
216 :
217 : using namespace ::com::sun::star::util;
218 : /// read a component (file + filter version)
219 18 : sal_Int32 ReadThroughComponent(
220 : const uno::Reference<XInputStream>& xInputStream,
221 : const uno::Reference<XComponent>& xModelComponent,
222 : const uno::Reference<XComponentContext> & rxContext,
223 : const uno::Reference< XDocumentHandler >& _xFilter )
224 : {
225 : OSL_ENSURE(xInputStream.is(), "input stream missing");
226 : OSL_ENSURE(xModelComponent.is(), "document missing");
227 : OSL_ENSURE(rxContext.is(), "factory missing");
228 :
229 : SAL_INFO("dbaccess", "dbaxml ReadThroughComponent" );
230 :
231 : // prepare ParserInputSrouce
232 18 : InputSource aParserInput;
233 18 : aParserInput.aInputStream = xInputStream;
234 :
235 : // get parser
236 36 : uno::Reference< XParser > xParser = Parser::create(rxContext);
237 : SAL_INFO("dbaccess", "parser created" );
238 :
239 : // get filter
240 : OSL_ENSURE( _xFilter.is(), "Can't instantiate filter component." );
241 18 : if( !_xFilter.is() )
242 0 : return 1;
243 :
244 : // connect parser and filter
245 18 : xParser->setDocumentHandler( _xFilter );
246 :
247 : // connect model and filter
248 36 : uno::Reference < XImporter > xImporter( _xFilter, UNO_QUERY );
249 18 : xImporter->setTargetDocument( xModelComponent );
250 :
251 :
252 :
253 : // finally, parser the stream
254 : try
255 : {
256 18 : xParser->parseStream( aParserInput );
257 : }
258 0 : catch (const SAXParseException& r)
259 : {
260 : #if OSL_DEBUG_LEVEL > 1
261 : SAL_WARN("dbaccess", "SAX parse exception catched while importing:\n" << r.Message << r.LineNumber << "," << r.ColumnNumber);
262 : #else
263 : (void)r;
264 : #endif
265 0 : return 1;
266 : }
267 0 : catch (const SAXException&)
268 : {
269 0 : return 1;
270 : }
271 0 : catch (const packages::zip::ZipIOException&)
272 : {
273 0 : return ERRCODE_IO_BROKENPACKAGE;
274 : }
275 0 : catch (const Exception&)
276 : {
277 : DBG_UNHANDLED_EXCEPTION();
278 : }
279 :
280 : // success!
281 36 : return 0;
282 : }
283 :
284 : /// read a component (storage version)
285 18 : sal_Int32 ReadThroughComponent(
286 : uno::Reference< embed::XStorage > xStorage,
287 : const uno::Reference<XComponent>& xModelComponent,
288 : const sal_Char* pStreamName,
289 : const sal_Char* pCompatibilityStreamName,
290 : const uno::Reference<XComponentContext> & rxContext,
291 : const uno::Reference< XDocumentHandler >& _xFilter)
292 : {
293 : OSL_ENSURE( xStorage.is(), "Need storage!");
294 : OSL_ENSURE(NULL != pStreamName, "Please, please, give me a name!");
295 :
296 18 : if ( xStorage.is() )
297 : {
298 18 : uno::Reference< io::XStream > xDocStream;
299 18 : sal_Bool bEncrypted = sal_False;
300 :
301 : try
302 : {
303 : // open stream (and set parser input)
304 18 : OUString sStreamName = OUString::createFromAscii(pStreamName);
305 18 : if ( !xStorage->hasByName( sStreamName ) || !xStorage->isStreamElement( sStreamName ) )
306 : {
307 : // stream name not found! Then try the compatibility name.
308 : // if no stream can be opened, return immediately with OK signal
309 :
310 : // do we even have an alternative name?
311 0 : if ( NULL == pCompatibilityStreamName )
312 0 : return 0;
313 :
314 : // if so, does the stream exist?
315 0 : sStreamName = OUString::createFromAscii(pCompatibilityStreamName);
316 0 : if ( !xStorage->hasByName( sStreamName ) || !xStorage->isStreamElement( sStreamName ) )
317 0 : return 0;
318 : }
319 :
320 : // get input stream
321 18 : xDocStream = xStorage->openStreamElement( sStreamName, embed::ElementModes::READ );
322 :
323 36 : uno::Reference< beans::XPropertySet > xProps( xDocStream, uno::UNO_QUERY_THROW );
324 36 : uno::Any aAny = xProps->getPropertyValue("Encrypted");
325 36 : aAny >>= bEncrypted;
326 : }
327 0 : catch (const packages::WrongPasswordException&)
328 : {
329 0 : return ERRCODE_SFX_WRONGPASSWORD;
330 : }
331 0 : catch (const uno::Exception&)
332 : {
333 0 : return 1; // TODO/LATER: error handling
334 : }
335 :
336 : #ifdef TIMELOG
337 : // if we do profiling, we want to know the stream
338 : SAL_INFO("dbaccess", "dbaxml ReadThroughComponent : parsing \"" << pStreamName << "\"" );
339 : #endif
340 :
341 36 : uno::Reference< XInputStream > xInputStream = xDocStream->getInputStream();
342 : // read from the stream
343 : return ReadThroughComponent( xInputStream
344 : ,xModelComponent
345 : ,rxContext
346 36 : ,_xFilter );
347 : }
348 :
349 : // TODO/LATER: better error handling
350 0 : return 1;
351 : }
352 :
353 : // -------------
354 : // - ODBFilter -
355 : // -------------
356 : DBG_NAME(ODBFilter)
357 :
358 9 : ODBFilter::ODBFilter( const uno::Reference< XComponentContext >& _rxContext )
359 : :SvXMLImport(_rxContext)
360 9 : ,m_bNewFormat(false)
361 : {
362 : DBG_CTOR(ODBFilter,NULL);
363 :
364 9 : GetMM100UnitConverter().SetCoreMeasureUnit(util::MeasureUnit::MM_10TH);
365 9 : GetMM100UnitConverter().SetXMLMeasureUnit(util::MeasureUnit::CM);
366 9 : GetNamespaceMap().Add( OUString ( sXML_np__db ),
367 9 : GetXMLToken(XML_N_DB),
368 18 : XML_NAMESPACE_DB );
369 :
370 9 : GetNamespaceMap().Add( OUString ( sXML_np___db ),
371 9 : GetXMLToken(XML_N_DB_OASIS),
372 18 : XML_NAMESPACE_DB );
373 9 : }
374 :
375 : // -----------------------------------------------------------------------------
376 :
377 18 : ODBFilter::~ODBFilter() throw()
378 : {
379 :
380 : DBG_DTOR(ODBFilter,NULL);
381 18 : }
382 : // -----------------------------------------------------------------------------
383 12 : IMPLEMENT_SERVICE_INFO_IMPLNAME_STATIC(ODBFilter, "com.sun.star.comp.sdb.DBFilter")
384 0 : IMPLEMENT_SERVICE_INFO_SUPPORTS(ODBFilter)
385 6 : IMPLEMENT_SERVICE_INFO_GETSUPPORTED1_STATIC(ODBFilter, "com.sun.star.document.ImportFilter")
386 :
387 : ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >
388 9 : SAL_CALL ODBFilter::Create(const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& _rxORB)
389 : {
390 9 : return static_cast< XServiceInfo* >(new ODBFilter( comphelper::getComponentContext(_rxORB)));
391 : }
392 :
393 : // -----------------------------------------------------------------------------
394 9 : sal_Bool SAL_CALL ODBFilter::filter( const Sequence< PropertyValue >& rDescriptor )
395 : throw (RuntimeException)
396 : {
397 9 : uno::Reference< ::com::sun::star::awt::XWindow > xWindow;
398 : {
399 9 : SolarMutexGuard aGuard;
400 9 : Window* pFocusWindow = Application::GetFocusWindow();
401 9 : xWindow = VCLUnoHelper::GetInterface( pFocusWindow );
402 9 : if( pFocusWindow )
403 5 : pFocusWindow->EnterWait();
404 : }
405 9 : sal_Bool bRet = sal_False;
406 :
407 9 : if ( GetModel().is() )
408 9 : bRet = implImport( rDescriptor );
409 :
410 9 : if ( xWindow.is() )
411 : {
412 5 : SolarMutexGuard aGuard;
413 5 : Window* pFocusWindow = VCLUnoHelper::GetWindow( xWindow );
414 5 : if ( pFocusWindow )
415 5 : pFocusWindow->LeaveWait();
416 : }
417 :
418 :
419 9 : return bRet;
420 : }
421 : // -----------------------------------------------------------------------------
422 9 : sal_Bool ODBFilter::implImport( const Sequence< PropertyValue >& rDescriptor )
423 : throw (RuntimeException)
424 : {
425 9 : OUString sFileName;
426 18 : ::comphelper::NamedValueCollection aMediaDescriptor( rDescriptor );
427 9 : if ( aMediaDescriptor.has( "URL" ) )
428 9 : sFileName = aMediaDescriptor.getOrDefault( "URL", OUString() );
429 9 : if ( sFileName.isEmpty() && aMediaDescriptor.has( "FileName" ) )
430 0 : sFileName = aMediaDescriptor.getOrDefault( "FileName", sFileName );
431 :
432 : OSL_ENSURE( !sFileName.isEmpty(), "ODBFilter::implImport: no URL given!" );
433 9 : sal_Bool bRet = !sFileName.isEmpty();
434 :
435 9 : if ( bRet )
436 : {
437 9 : uno::Reference<XComponent> xCom(GetModel(),UNO_QUERY);
438 :
439 : SfxMediumRef pMedium = new SfxMedium(
440 18 : sFileName, ( STREAM_READ | STREAM_NOCREATE ) );
441 18 : uno::Reference< embed::XStorage > xStorage;
442 : try
443 : {
444 9 : xStorage.set( pMedium->GetStorage( sal_False ), UNO_QUERY_THROW );
445 : }
446 0 : catch (const Exception&)
447 : {
448 0 : Any aError = ::cppu::getCaughtException();
449 0 : if ( aError.isExtractableTo( ::cppu::UnoType< RuntimeException >::get() ) )
450 0 : throw;
451 0 : throw lang::WrappedTargetRuntimeException( OUString(), *this, aError );
452 : }
453 :
454 18 : uno::Reference<sdb::XOfficeDatabaseDocument> xOfficeDoc(GetModel(),UNO_QUERY_THROW);
455 9 : m_xDataSource.set(xOfficeDoc->getDataSource(),UNO_QUERY_THROW);
456 18 : uno::Reference<beans::XPropertyChangeListener> xListener = new DatasourceURLListener( GetComponentContext());
457 9 : m_xDataSource->addPropertyChangeListener(PROPERTY_URL,xListener);
458 18 : uno::Reference< XNumberFormatsSupplier > xNum(m_xDataSource->getPropertyValue(PROPERTY_NUMBERFORMATSSUPPLIER),UNO_QUERY);
459 9 : SetNumberFormatsSupplier(xNum);
460 :
461 18 : uno::Reference<XComponent> xModel(GetModel(),UNO_QUERY);
462 : sal_Int32 nRet = ReadThroughComponent( xStorage
463 : ,xModel
464 : ,"settings.xml"
465 : ,"Settings.xml"
466 : ,GetComponentContext()
467 : ,this
468 9 : );
469 :
470 9 : if ( nRet == 0 )
471 : nRet = ReadThroughComponent( xStorage
472 : ,xModel
473 : ,"content.xml"
474 : ,"Content.xml"
475 : ,GetComponentContext()
476 : ,this
477 9 : );
478 :
479 9 : bRet = nRet == 0;
480 :
481 9 : if ( bRet )
482 : {
483 9 : uno::Reference< XModifiable > xModi(GetModel(),UNO_QUERY);
484 9 : if ( xModi.is() )
485 9 : xModi->setModified(sal_False);
486 : }
487 : else
488 : {
489 0 : switch( nRet )
490 : {
491 : case ERRCODE_IO_BROKENPACKAGE:
492 : // TODO/LATER: no way to transport the error outside from the filter!
493 0 : break;
494 : default:
495 : {
496 : // TODO/LATER: this is completely wrong! Filter code should never call ErrorHandler directly! But for now this is the only way!
497 0 : ErrorHandler::HandleError( nRet );
498 0 : if( nRet & ERRCODE_WARNING_MASK )
499 0 : bRet = sal_True;
500 : }
501 : }
502 9 : }
503 : }
504 :
505 18 : return bRet;
506 : }
507 : // -----------------------------------------------------------------------------
508 71 : SvXMLImportContext* ODBFilter::CreateContext( sal_uInt16 nPrefix,
509 : const OUString& rLocalName,
510 : const uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList )
511 : {
512 71 : SvXMLImportContext *pContext = 0;
513 :
514 71 : const SvXMLTokenMap& rTokenMap = GetDocElemTokenMap();
515 71 : switch( rTokenMap.Get( nPrefix, rLocalName ) )
516 : {
517 : case XML_TOK_DOC_SETTINGS:
518 0 : GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP );
519 0 : pContext = new XMLDocumentSettingsContext( *this, nPrefix, rLocalName,xAttrList );
520 0 : break;
521 : case XML_TOK_DOC_DATABASE:
522 9 : GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP );
523 9 : pContext = new OXMLDatabase( *this, nPrefix, rLocalName );
524 9 : break;
525 : case XML_TOK_DOC_STYLES:
526 0 : GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP );
527 0 : pContext = CreateStylesContext(nPrefix, rLocalName, xAttrList, sal_False);
528 0 : break;
529 : case XML_TOK_DOC_AUTOSTYLES:
530 9 : GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP );
531 9 : pContext = CreateStylesContext(nPrefix, rLocalName, xAttrList, sal_True);
532 9 : break;
533 : case XML_TOK_DOC_SCRIPT:
534 9 : pContext = CreateScriptContext( rLocalName );
535 9 : break;
536 : }
537 :
538 71 : if ( !pContext )
539 44 : pContext = SvXMLImport::CreateContext( nPrefix, rLocalName, xAttrList );
540 :
541 71 : return pContext;
542 : }
543 : // -----------------------------------------------------------------------------
544 0 : void ODBFilter::SetViewSettings(const Sequence<PropertyValue>& aViewProps)
545 : {
546 0 : const PropertyValue *pIter = aViewProps.getConstArray();
547 0 : const PropertyValue *pEnd = pIter + aViewProps.getLength();
548 0 : for (; pIter != pEnd; ++pIter)
549 : {
550 0 : if ( pIter->Name == "Queries" )
551 : {
552 0 : fillPropertyMap(pIter->Value,m_aQuerySettings);
553 : }
554 0 : else if ( pIter->Name == "Tables" )
555 : {
556 0 : fillPropertyMap(pIter->Value,m_aTablesSettings);
557 : }
558 : }
559 0 : }
560 : // -----------------------------------------------------------------------------
561 0 : void ODBFilter::SetConfigurationSettings(const Sequence<PropertyValue>& aConfigProps)
562 : {
563 0 : const PropertyValue *pIter = aConfigProps.getConstArray();
564 0 : const PropertyValue *pEnd = pIter + aConfigProps.getLength();
565 0 : for (; pIter != pEnd; ++pIter)
566 : {
567 0 : if ( pIter->Name == "layout-settings" )
568 : {
569 0 : Sequence<PropertyValue> aWindows;
570 0 : pIter->Value >>= aWindows;
571 0 : uno::Reference<XPropertySet> xProp(getDataSource());
572 0 : if ( xProp.is() )
573 0 : xProp->setPropertyValue(PROPERTY_LAYOUTINFORMATION,makeAny(aWindows));
574 : }
575 : }
576 0 : }
577 : // -----------------------------------------------------------------------------
578 0 : void ODBFilter::fillPropertyMap(const Any& _rValue,TPropertyNameMap& _rMap)
579 : {
580 0 : Sequence<PropertyValue> aWindows;
581 0 : _rValue >>= aWindows;
582 0 : const PropertyValue *pIter = aWindows.getConstArray();
583 0 : const PropertyValue *pEnd = pIter + aWindows.getLength();
584 0 : for (; pIter != pEnd; ++pIter)
585 : {
586 0 : Sequence<PropertyValue> aValue;
587 0 : pIter->Value >>= aValue;
588 0 : _rMap.insert(TPropertyNameMap::value_type(pIter->Name,aValue));
589 0 : }
590 :
591 0 : }
592 : // -----------------------------------------------------------------------------
593 71 : const SvXMLTokenMap& ODBFilter::GetDocElemTokenMap() const
594 : {
595 71 : if ( !m_pDocElemTokenMap.get() )
596 : {
597 : static SvXMLTokenMapEntry aElemTokenMap[]=
598 : {
599 : { XML_NAMESPACE_OFFICE, XML_SETTINGS, XML_TOK_DOC_SETTINGS },
600 : { XML_NAMESPACE_OOO, XML_SETTINGS, XML_TOK_DOC_SETTINGS },
601 : { XML_NAMESPACE_OFFICE, XML_STYLES, XML_TOK_DOC_STYLES },
602 : { XML_NAMESPACE_OOO, XML_STYLES, XML_TOK_DOC_STYLES },
603 : { XML_NAMESPACE_OFFICE, XML_AUTOMATIC_STYLES, XML_TOK_DOC_AUTOSTYLES },
604 : { XML_NAMESPACE_OOO, XML_AUTOMATIC_STYLES, XML_TOK_DOC_AUTOSTYLES },
605 : { XML_NAMESPACE_OFFICE, XML_DATABASE, XML_TOK_DOC_DATABASE },
606 : { XML_NAMESPACE_OOO, XML_DATABASE, XML_TOK_DOC_DATABASE },
607 : { XML_NAMESPACE_OFFICE, XML_SCRIPTS, XML_TOK_DOC_SCRIPT },
608 : XML_TOKEN_MAP_END
609 : };
610 9 : m_pDocElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
611 : }
612 71 : return *m_pDocElemTokenMap;
613 : }
614 : // -----------------------------------------------------------------------------
615 17 : const SvXMLTokenMap& ODBFilter::GetDatabaseElemTokenMap() const
616 : {
617 17 : if ( !m_pDatabaseElemTokenMap.get() )
618 : {
619 : static SvXMLTokenMapEntry aElemTokenMap[]=
620 : {
621 : { XML_NAMESPACE_DB, XML_DATASOURCE, XML_TOK_DATASOURCE },
622 : { XML_NAMESPACE_DB, XML_FORMS, XML_TOK_FORMS},
623 : { XML_NAMESPACE_DB, XML_REPORTS, XML_TOK_REPORTS},
624 : { XML_NAMESPACE_DB, XML_QUERIES, XML_TOK_QUERIES},
625 : { XML_NAMESPACE_DB, XML_TABLES, XML_TOK_TABLES},
626 : { XML_NAMESPACE_DB, XML_TABLE_REPRESENTATIONS, XML_TOK_TABLES},
627 : { XML_NAMESPACE_DB, XML_SCHEMA_DEFINITION, XML_TOK_SCHEMA_DEFINITION},
628 : XML_TOKEN_MAP_END
629 : };
630 9 : m_pDatabaseElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
631 : }
632 17 : return *m_pDatabaseElemTokenMap;
633 : }
634 : // -----------------------------------------------------------------------------
635 98 : const SvXMLTokenMap& ODBFilter::GetDataSourceElemTokenMap() const
636 : {
637 98 : if ( !m_pDataSourceElemTokenMap.get() )
638 : {
639 : static SvXMLTokenMapEntry aElemTokenMap[]=
640 : {
641 : { XML_NAMESPACE_DB, XML_CONNECTION_RESOURCE, XML_TOK_CONNECTION_RESOURCE},
642 : { XML_NAMESPACE_DB, XML_SUPPRESS_VERSION_COLUMNS, XML_TOK_SUPPRESS_VERSION_COLUMNS},
643 : { XML_NAMESPACE_DB, XML_JAVA_DRIVER_CLASS, XML_TOK_JAVA_DRIVER_CLASS},
644 : { XML_NAMESPACE_DB, XML_EXTENSION, XML_TOK_EXTENSION},
645 : { XML_NAMESPACE_DB, XML_IS_FIRST_ROW_HEADER_LINE, XML_TOK_IS_FIRST_ROW_HEADER_LINE},
646 : { XML_NAMESPACE_DB, XML_SHOW_DELETED, XML_TOK_SHOW_DELETED},
647 : { XML_NAMESPACE_DB, XML_IS_TABLE_NAME_LENGTH_LIMITED, XML_TOK_IS_TABLE_NAME_LENGTH_LIMITED},
648 : { XML_NAMESPACE_DB, XML_SYSTEM_DRIVER_SETTINGS, XML_TOK_SYSTEM_DRIVER_SETTINGS},
649 : { XML_NAMESPACE_DB, XML_ENABLE_SQL92_CHECK, XML_TOK_ENABLE_SQL92_CHECK},
650 : { XML_NAMESPACE_DB, XML_APPEND_TABLE_ALIAS_NAME, XML_TOK_APPEND_TABLE_ALIAS_NAME},
651 : { XML_NAMESPACE_DB, XML_PARAMETER_NAME_SUBSTITUTION, XML_TOK_PARAMETER_NAME_SUBSTITUTION},
652 : { XML_NAMESPACE_DB, XML_IGNORE_DRIVER_PRIVILEGES, XML_TOK_IGNORE_DRIVER_PRIVILEGES},
653 : { XML_NAMESPACE_DB, XML_BOOLEAN_COMPARISON_MODE, XML_TOK_BOOLEAN_COMPARISON_MODE},
654 : { XML_NAMESPACE_DB, XML_USE_CATALOG, XML_TOK_USE_CATALOG},
655 : { XML_NAMESPACE_DB, XML_BASE_DN, XML_TOK_BASE_DN},
656 : { XML_NAMESPACE_DB, XML_MAX_ROW_COUNT, XML_TOK_MAX_ROW_COUNT},
657 : { XML_NAMESPACE_DB, XML_LOGIN, XML_TOK_LOGIN},
658 : { XML_NAMESPACE_DB, XML_TABLE_FILTER, XML_TOK_TABLE_FILTER},
659 : { XML_NAMESPACE_DB, XML_TABLE_TYPE_FILTER, XML_TOK_TABLE_TYPE_FILTER},
660 : { XML_NAMESPACE_DB, XML_AUTO_INCREMENT, XML_TOK_AUTO_INCREMENT},
661 : { XML_NAMESPACE_DB, XML_DELIMITER, XML_TOK_DELIMITER},
662 : { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTINGS, XML_TOK_DATA_SOURCE_SETTINGS},
663 : { XML_NAMESPACE_DB, XML_FONT_CHARSET, XML_TOK_FONT_CHARSET},
664 : // db odf 12
665 : { XML_NAMESPACE_DB, XML_CONNECTION_DATA, XML_TOK_CONNECTION_DATA},
666 : { XML_NAMESPACE_DB, XML_DATABASE_DESCRIPTION, XML_TOK_DATABASE_DESCRIPTION},
667 : { XML_NAMESPACE_DB, XML_COMPOUND_DATABASE, XML_TOK_COMPOUND_DATABASE},
668 : { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_DB_HREF},
669 : { XML_NAMESPACE_DB, XML_MEDIA_TYPE, XML_TOK_MEDIA_TYPE},
670 : { XML_NAMESPACE_DB, XML_TYPE, XML_TOK_DB_TYPE},
671 : { XML_NAMESPACE_DB, XML_HOSTNAME, XML_TOK_HOSTNAME},
672 : { XML_NAMESPACE_DB, XML_PORT, XML_TOK_PORT},
673 : { XML_NAMESPACE_DB, XML_LOCAL_SOCKET, XML_TOK_LOCAL_SOCKET},
674 : { XML_NAMESPACE_DB, XML_DATABASE_NAME, XML_TOK_DATABASE_NAME},
675 : { XML_NAMESPACE_DB, XML_DRIVER_SETTINGS, XML_TOK_DRIVER_SETTINGS},
676 : { XML_NAMESPACE_DB, XML_JAVA_CLASSPATH, XML_TOK_JAVA_CLASSPATH},
677 : { XML_NAMESPACE_DB, XML_CHARACTER_SET, XML_TOK_CHARACTER_SET},
678 : { XML_NAMESPACE_DB, XML_APPLICATION_CONNECTION_SETTINGS,XML_TOK_APPLICATION_CONNECTION_SETTINGS},
679 : XML_TOKEN_MAP_END
680 : };
681 9 : m_pDataSourceElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
682 : }
683 98 : return *m_pDataSourceElemTokenMap;
684 : }
685 : // -----------------------------------------------------------------------------
686 9 : const SvXMLTokenMap& ODBFilter::GetLoginElemTokenMap() const
687 : {
688 9 : if ( !m_pLoginElemTokenMap.get() )
689 : {
690 : static SvXMLTokenMapEntry aElemTokenMap[]=
691 : {
692 : { XML_NAMESPACE_DB, XML_USER_NAME, XML_TOK_USER_NAME},
693 : { XML_NAMESPACE_DB, XML_IS_PASSWORD_REQUIRED, XML_TOK_IS_PASSWORD_REQUIRED},
694 : { XML_NAMESPACE_DB, XML_USE_SYSTEM_USER, XML_TOK_USE_SYSTEM_USER},
695 : { XML_NAMESPACE_DB, XML_LOGIN_TIMEOUT, XML_TOK_LOGIN_TIMEOUT},
696 : XML_TOKEN_MAP_END
697 : };
698 9 : m_pLoginElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
699 : }
700 9 : return *m_pLoginElemTokenMap;
701 : }
702 : // -----------------------------------------------------------------------------
703 9 : const SvXMLTokenMap& ODBFilter::GetDatabaseDescriptionElemTokenMap() const
704 : {
705 9 : if ( !m_pDatabaseDescriptionElemTokenMap.get() )
706 : {
707 : static SvXMLTokenMapEntry aElemTokenMap[]=
708 : {
709 : { XML_NAMESPACE_DB, XML_FILE_BASED_DATABASE, XML_TOK_FILE_BASED_DATABASE},
710 : { XML_NAMESPACE_DB, XML_SERVER_DATABASE, XML_TOK_SERVER_DATABASE},
711 : XML_TOKEN_MAP_END
712 : };
713 9 : m_pDatabaseDescriptionElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
714 : }
715 9 : return *m_pDatabaseDescriptionElemTokenMap;
716 : }
717 : // -----------------------------------------------------------------------------
718 8 : const SvXMLTokenMap& ODBFilter::GetDataSourceInfoElemTokenMap() const
719 : {
720 8 : if ( !m_pDataSourceInfoElemTokenMap.get() )
721 : {
722 : static SvXMLTokenMapEntry aElemTokenMap[]=
723 : {
724 : { XML_NAMESPACE_DB, XML_ADDITIONAL_COLUMN_STATEMENT,XML_TOK_ADDITIONAL_COLUMN_STATEMENT},
725 : { XML_NAMESPACE_DB, XML_ROW_RETRIEVING_STATEMENT, XML_TOK_ROW_RETRIEVING_STATEMENT},
726 : { XML_NAMESPACE_DB, XML_STRING, XML_TOK_STRING},
727 : { XML_NAMESPACE_DB, XML_FIELD, XML_TOK_FIELD},
728 : { XML_NAMESPACE_DB, XML_DECIMAL, XML_TOK_DECIMAL},
729 : { XML_NAMESPACE_DB, XML_THOUSAND, XML_TOK_THOUSAND},
730 : { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING, XML_TOK_DATA_SOURCE_SETTING},
731 : { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING_VALUE, XML_TOK_DATA_SOURCE_SETTING_VALUE},
732 : { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING_IS_LIST,XML_TOK_DATA_SOURCE_SETTING_IS_LIST},
733 : { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING_TYPE, XML_TOK_DATA_SOURCE_SETTING_TYPE},
734 : { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING_NAME, XML_TOK_DATA_SOURCE_SETTING_NAME},
735 : { XML_NAMESPACE_DB, XML_FONT_CHARSET, XML_TOK_FONT_CHARSET},
736 : { XML_NAMESPACE_DB, XML_ENCODING, XML_TOK_ENCODING},
737 : XML_TOKEN_MAP_END
738 : };
739 8 : m_pDataSourceInfoElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
740 : }
741 8 : return *m_pDataSourceInfoElemTokenMap;
742 : }
743 : // -----------------------------------------------------------------------------
744 256 : const SvXMLTokenMap& ODBFilter::GetDocumentsElemTokenMap() const
745 : {
746 256 : if ( !m_pDocumentsElemTokenMap.get() )
747 : {
748 : static SvXMLTokenMapEntry aElemTokenMap[]=
749 : {
750 : { XML_NAMESPACE_DB, XML_COMPONENT, XML_TOK_COMPONENT},
751 : { XML_NAMESPACE_DB, XML_COMPONENT_COLLECTION, XML_TOK_COMPONENT_COLLECTION},
752 : { XML_NAMESPACE_DB, XML_QUERY_COLLECTION, XML_TOK_QUERY_COLLECTION},
753 : { XML_NAMESPACE_DB, XML_QUERY, XML_TOK_QUERY},
754 : { XML_NAMESPACE_DB, XML_TABLE, XML_TOK_TABLE},
755 : { XML_NAMESPACE_DB, XML_TABLE_REPRESENTATION, XML_TOK_TABLE},
756 : { XML_NAMESPACE_DB, XML_COLUMN, XML_TOK_COLUMN},
757 : XML_TOKEN_MAP_END
758 : };
759 8 : m_pDocumentsElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
760 : }
761 256 : return *m_pDocumentsElemTokenMap;
762 : }
763 : // -----------------------------------------------------------------------------
764 0 : const SvXMLTokenMap& ODBFilter::GetComponentElemTokenMap() const
765 : {
766 0 : if ( !m_pComponentElemTokenMap.get() )
767 : {
768 : static SvXMLTokenMapEntry aElemTokenMap[]=
769 : {
770 : { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_HREF },
771 : { XML_NAMESPACE_XLINK, XML_TYPE, XML_TOK_TYPE },
772 : { XML_NAMESPACE_XLINK, XML_SHOW, XML_TOK_SHOW },
773 : { XML_NAMESPACE_XLINK, XML_ACTUATE, XML_TOK_ACTUATE},
774 : { XML_NAMESPACE_DB, XML_AS_TEMPLATE, XML_TOK_AS_TEMPLATE },
775 : { XML_NAMESPACE_DB, XML_NAME, XML_TOK_COMPONENT_NAME },
776 : XML_TOKEN_MAP_END
777 : };
778 0 : m_pComponentElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
779 : }
780 0 : return *m_pComponentElemTokenMap;
781 : }
782 : // -----------------------------------------------------------------------------
783 40 : const SvXMLTokenMap& ODBFilter::GetQueryElemTokenMap() const
784 : {
785 40 : if ( !m_pQueryElemTokenMap.get() )
786 : {
787 : static SvXMLTokenMapEntry aElemTokenMap[]=
788 : {
789 : { XML_NAMESPACE_DB, XML_COMMAND, XML_TOK_COMMAND },
790 : { XML_NAMESPACE_DB, XML_ESCAPE_PROCESSING, XML_TOK_ESCAPE_PROCESSING },
791 : { XML_NAMESPACE_DB, XML_NAME, XML_TOK_QUERY_NAME },
792 : { XML_NAMESPACE_DB, XML_FILTER_STATEMENT, XML_TOK_FILTER_STATEMENT },
793 : { XML_NAMESPACE_DB, XML_ORDER_STATEMENT, XML_TOK_ORDER_STATEMENT },
794 : { XML_NAMESPACE_DB, XML_CATALOG_NAME, XML_TOK_CATALOG_NAME },
795 : { XML_NAMESPACE_DB, XML_SCHEMA_NAME, XML_TOK_SCHEMA_NAME },
796 : { XML_NAMESPACE_DB, XML_STYLE_NAME, XML_TOK_STYLE_NAME},
797 : { XML_NAMESPACE_DB, XML_APPLY_FILTER, XML_TOK_APPLY_FILTER},
798 : { XML_NAMESPACE_DB, XML_APPLY_ORDER, XML_TOK_APPLY_ORDER},
799 : { XML_NAMESPACE_DB, XML_COLUMNS, XML_TOK_COLUMNS},
800 : XML_TOKEN_MAP_END
801 : };
802 8 : m_pQueryElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
803 : }
804 40 : return *m_pQueryElemTokenMap;
805 : }
806 : // -----------------------------------------------------------------------------
807 240 : const SvXMLTokenMap& ODBFilter::GetColumnElemTokenMap() const
808 : {
809 240 : if ( !m_pColumnElemTokenMap.get() )
810 : {
811 : static SvXMLTokenMapEntry aElemTokenMap[]=
812 : {
813 : { XML_NAMESPACE_DB, XML_NAME, XML_TOK_COLUMN_NAME },
814 : { XML_NAMESPACE_DB, XML_STYLE_NAME, XML_TOK_COLUMN_STYLE_NAME },
815 : { XML_NAMESPACE_DB, XML_HELP_MESSAGE, XML_TOK_COLUMN_HELP_MESSAGE },
816 : { XML_NAMESPACE_DB, XML_VISIBILITY, XML_TOK_COLUMN_VISIBILITY },
817 : { XML_NAMESPACE_DB, XML_DEFAULT_VALUE, XML_TOK_COLUMN_DEFAULT_VALUE },
818 : { XML_NAMESPACE_DB, XML_TYPE_NAME, XML_TOK_COLUMN_TYPE_NAME },
819 : { XML_NAMESPACE_DB, XML_VISIBLE, XML_TOK_COLUMN_VISIBLE },
820 : { XML_NAMESPACE_DB, XML_DEFAULT_CELL_STYLE_NAME, XML_TOK_DEFAULT_CELL_STYLE_NAME },
821 : XML_TOKEN_MAP_END
822 : };
823 8 : m_pColumnElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
824 : }
825 240 : return *m_pColumnElemTokenMap;
826 : }
827 : // -----------------------------------------------------------------------------
828 9 : SvXMLImportContext* ODBFilter::CreateStylesContext(sal_uInt16 _nPrefix,const OUString& rLocalName,
829 : const uno::Reference< XAttributeList>& xAttrList, sal_Bool bIsAutoStyle )
830 : {
831 9 : SvXMLImportContext *pContext = NULL;
832 9 : if (!pContext)
833 : {
834 9 : pContext = new OTableStylesContext(*this, _nPrefix, rLocalName, xAttrList, bIsAutoStyle);
835 9 : if (bIsAutoStyle)
836 9 : SetAutoStyles((SvXMLStylesContext*)pContext);
837 : else
838 0 : SetStyles((SvXMLStylesContext*)pContext);
839 : }
840 9 : return pContext;
841 : }
842 : // -----------------------------------------------------------------------------
843 9 : SvXMLImportContext* ODBFilter::CreateScriptContext( const OUString& _rLocalName )
844 : {
845 9 : return new XMLScriptContext( *this, XML_NAMESPACE_OFFICE, _rLocalName, GetModel() );
846 : }
847 : // -----------------------------------------------------------------------------
848 0 : UniReference < XMLPropertySetMapper > ODBFilter::GetTableStylesPropertySetMapper() const
849 : {
850 0 : if ( !m_xTableStylesPropertySetMapper.is() )
851 : {
852 0 : m_xTableStylesPropertySetMapper = OXMLHelper::GetTableStylesPropertySetMapper();
853 : }
854 0 : return m_xTableStylesPropertySetMapper;
855 : }
856 : // -----------------------------------------------------------------------------
857 8 : UniReference < XMLPropertySetMapper > ODBFilter::GetColumnStylesPropertySetMapper() const
858 : {
859 8 : if ( !m_xColumnStylesPropertySetMapper.is() )
860 : {
861 8 : m_xColumnStylesPropertySetMapper = OXMLHelper::GetColumnStylesPropertySetMapper();
862 : }
863 8 : return m_xColumnStylesPropertySetMapper;
864 : }
865 : // -----------------------------------------------------------------------------
866 8 : UniReference < XMLPropertySetMapper > ODBFilter::GetCellStylesPropertySetMapper() const
867 : {
868 8 : if ( !m_xCellStylesPropertySetMapper.is() )
869 : {
870 8 : m_xCellStylesPropertySetMapper = OXMLHelper::GetCellStylesPropertySetMapper();
871 : }
872 8 : return m_xCellStylesPropertySetMapper;
873 : }
874 : // -----------------------------------------------------------------------------
875 9 : void ODBFilter::setPropertyInfo()
876 : {
877 9 : Reference<XPropertySet> xDataSource(getDataSource());
878 9 : if ( !xDataSource.is() )
879 9 : return;
880 :
881 18 : ::connectivity::DriversConfig aDriverConfig(GetComponentContext());
882 18 : const OUString sURL = ::comphelper::getString(xDataSource->getPropertyValue(PROPERTY_URL));
883 18 : ::comphelper::NamedValueCollection aDataSourceSettings = aDriverConfig.getProperties( sURL );
884 :
885 18 : Sequence<PropertyValue> aInfo;
886 9 : if ( !m_aInfoSequence.empty() )
887 9 : aInfo = Sequence<PropertyValue>(&(*m_aInfoSequence.begin()),m_aInfoSequence.size());
888 9 : aDataSourceSettings.merge( ::comphelper::NamedValueCollection( aInfo ), true );
889 :
890 9 : aDataSourceSettings >>= aInfo;
891 9 : if ( aInfo.getLength() )
892 : {
893 : try
894 : {
895 9 : xDataSource->setPropertyValue(PROPERTY_INFO,makeAny(aInfo));
896 : }
897 0 : catch (const Exception&)
898 : {
899 : DBG_UNHANDLED_EXCEPTION();
900 : }
901 9 : }
902 : }
903 : // -----------------------------------------------------------------------------
904 18 : }// dbaxml
905 : // -----------------------------------------------------------------------------
906 :
907 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
