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 : #include <sal/config.h>
21 :
22 : #include <boost/noncopyable.hpp>
23 : #include <com/sun/star/util/MeasureUnit.hpp>
24 : #include <com/sun/star/packages/zip/ZipIOException.hpp>
25 : #include <com/sun/star/embed/ElementModes.hpp>
26 : #include <com/sun/star/sdb/XOfficeDatabaseDocument.hpp>
27 : #include "xmlfilter.hxx"
28 : #include "xmlservices.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/lang/WrappedTargetRuntimeException.hpp>
52 : #include <osl/mutex.hxx>
53 : #include <svtools/sfxecode.hxx>
54 : #include <toolkit/helper/vclunohelper.hxx>
55 : #include <tools/diagnose_ex.h>
56 : #include <osl/diagnose.h>
57 : #include <comphelper/processfactory.hxx>
58 : #include <comphelper/namedvaluecollection.hxx>
59 : #include <comphelper/uno3.hxx>
60 : #include <cppuhelper/exc_hlp.hxx>
61 : #include <connectivity/DriversConfig.hxx>
62 : #include "dsntypes.hxx"
63 : #include <rtl/strbuf.hxx>
64 :
65 : using namespace ::com::sun::star;
66 :
67 23 : extern "C" void SAL_CALL createRegistryInfo_ODBFilter( )
68 : {
69 23 : static ::dbaxml::OMultiInstanceAutoRegistration< ::dbaxml::ODBFilter > aAutoRegistration;
70 23 : }
71 :
72 : namespace dbaxml
73 : {
74 : sal_Char const sXML_np__db[] = "_db";
75 : sal_Char const sXML_np___db[] = "__db";
76 :
77 : using namespace ::com::sun::star::util;
78 : /// read a component (file + filter version)
79 32 : sal_Int32 ReadThroughComponent(
80 : const uno::Reference<XInputStream>& xInputStream,
81 : const uno::Reference<XComponent>& xModelComponent,
82 : const uno::Reference<XComponentContext> & rxContext,
83 : const uno::Reference< XDocumentHandler >& _xFilter )
84 : {
85 : OSL_ENSURE(xInputStream.is(), "input stream missing");
86 : OSL_ENSURE(xModelComponent.is(), "document missing");
87 : OSL_ENSURE(rxContext.is(), "factory missing");
88 :
89 : // prepare ParserInputSrouce
90 32 : InputSource aParserInput;
91 32 : aParserInput.aInputStream = xInputStream;
92 :
93 : // get parser
94 64 : uno::Reference< XParser > xParser = Parser::create(rxContext);
95 : SAL_INFO("dbaccess", "parser created" );
96 :
97 : // get filter
98 : OSL_ENSURE( _xFilter.is(), "Can't instantiate filter component." );
99 32 : if( !_xFilter.is() )
100 0 : return 1;
101 :
102 : // connect parser and filter
103 32 : xParser->setDocumentHandler( _xFilter );
104 :
105 : // connect model and filter
106 64 : uno::Reference < XImporter > xImporter( _xFilter, UNO_QUERY );
107 32 : xImporter->setTargetDocument( xModelComponent );
108 :
109 : // finally, parser the stream
110 : try
111 : {
112 32 : xParser->parseStream( aParserInput );
113 : }
114 0 : catch (const SAXParseException& r)
115 : {
116 : #if OSL_DEBUG_LEVEL > 1
117 : SAL_WARN("dbaccess", "SAX parse exception catched while importing:\n" << r.Message << r.LineNumber << "," << r.ColumnNumber);
118 : #else
119 : (void)r;
120 : #endif
121 0 : return 1;
122 : }
123 0 : catch (const SAXException&)
124 : {
125 0 : return 1;
126 : }
127 0 : catch (const packages::zip::ZipIOException&)
128 : {
129 0 : return ERRCODE_IO_BROKENPACKAGE;
130 : }
131 0 : catch (const Exception&)
132 : {
133 : DBG_UNHANDLED_EXCEPTION();
134 : }
135 :
136 : // success!
137 64 : return 0;
138 : }
139 :
140 : /// read a component (storage version)
141 32 : sal_Int32 ReadThroughComponent(
142 : uno::Reference< embed::XStorage > xStorage,
143 : const uno::Reference<XComponent>& xModelComponent,
144 : const sal_Char* pStreamName,
145 : const sal_Char* pCompatibilityStreamName,
146 : const uno::Reference<XComponentContext> & rxContext,
147 : const uno::Reference< XDocumentHandler >& _xFilter)
148 : {
149 : OSL_ENSURE( xStorage.is(), "Need storage!");
150 : OSL_ENSURE(NULL != pStreamName, "Please, please, give me a name!");
151 :
152 32 : if ( xStorage.is() )
153 : {
154 32 : uno::Reference< io::XStream > xDocStream;
155 :
156 : try
157 : {
158 32 : bool bEncrypted = false;
159 : // open stream (and set parser input)
160 32 : OUString sStreamName = OUString::createFromAscii(pStreamName);
161 32 : if ( !xStorage->hasByName( sStreamName ) || !xStorage->isStreamElement( sStreamName ) )
162 : {
163 : // stream name not found! Then try the compatibility name.
164 : // if no stream can be opened, return immediately with OK signal
165 :
166 : // do we even have an alternative name?
167 0 : if ( NULL == pCompatibilityStreamName )
168 0 : return 0;
169 :
170 : // if so, does the stream exist?
171 0 : sStreamName = OUString::createFromAscii(pCompatibilityStreamName);
172 0 : if ( !xStorage->hasByName( sStreamName ) || !xStorage->isStreamElement( sStreamName ) )
173 0 : return 0;
174 : }
175 :
176 : // get input stream
177 32 : xDocStream = xStorage->openStreamElement( sStreamName, embed::ElementModes::READ );
178 :
179 64 : uno::Reference< beans::XPropertySet > xProps( xDocStream, uno::UNO_QUERY_THROW );
180 64 : uno::Any aAny = xProps->getPropertyValue("Encrypted");
181 64 : aAny >>= bEncrypted;
182 : }
183 0 : catch (const packages::WrongPasswordException&)
184 : {
185 0 : return ERRCODE_SFX_WRONGPASSWORD;
186 : }
187 0 : catch (const uno::Exception&)
188 : {
189 0 : return 1; // TODO/LATER: error handling
190 : }
191 :
192 64 : uno::Reference< XInputStream > xInputStream = xDocStream->getInputStream();
193 : // read from the stream
194 : return ReadThroughComponent( xInputStream
195 : ,xModelComponent
196 : ,rxContext
197 64 : ,_xFilter );
198 : }
199 :
200 : // TODO/LATER: better error handling
201 0 : return 1;
202 : }
203 :
204 : // - ODBFilter -
205 :
206 17 : ODBFilter::ODBFilter( const uno::Reference< XComponentContext >& _rxContext )
207 : : SvXMLImport(_rxContext, getImplementationName_Static())
208 : , m_nPreviewMode(0)
209 17 : , m_bNewFormat(false)
210 : {
211 :
212 17 : GetMM100UnitConverter().SetCoreMeasureUnit(util::MeasureUnit::MM_10TH);
213 17 : GetMM100UnitConverter().SetXMLMeasureUnit(util::MeasureUnit::CM);
214 17 : GetNamespaceMap().Add( OUString ( sXML_np__db ),
215 17 : GetXMLToken(XML_N_DB),
216 34 : XML_NAMESPACE_DB );
217 :
218 17 : GetNamespaceMap().Add( OUString ( sXML_np___db ),
219 17 : GetXMLToken(XML_N_DB_OASIS),
220 34 : XML_NAMESPACE_DB );
221 17 : }
222 :
223 34 : ODBFilter::~ODBFilter() throw()
224 : {
225 :
226 34 : }
227 :
228 63 : OUString ODBFilter::getImplementationName_Static()
229 : throw (css::uno::RuntimeException)
230 : {
231 63 : return OUString("com.sun.star.comp.sdb.DBFilter");
232 : }
233 :
234 23 : css::uno::Sequence<OUString> ODBFilter::getSupportedServiceNames_Static()
235 : throw (css::uno::RuntimeException)
236 : {
237 23 : css::uno::Sequence<OUString> s(1);
238 23 : s[0] = "com.sun.star.document.ImportFilter";
239 23 : return s;
240 : }
241 :
242 : ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >
243 17 : SAL_CALL ODBFilter::Create(const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& _rxORB)
244 : {
245 17 : return static_cast< XServiceInfo* >(new ODBFilter( comphelper::getComponentContext(_rxORB)));
246 : }
247 :
248 16 : sal_Bool SAL_CALL ODBFilter::filter( const Sequence< PropertyValue >& rDescriptor )
249 : throw (RuntimeException, std::exception)
250 : {
251 16 : uno::Reference< ::com::sun::star::awt::XWindow > xWindow;
252 : {
253 16 : SolarMutexGuard aGuard;
254 16 : vcl::Window* pFocusWindow = Application::GetFocusWindow();
255 16 : xWindow = VCLUnoHelper::GetInterface( pFocusWindow );
256 16 : if( pFocusWindow )
257 5 : pFocusWindow->EnterWait();
258 : }
259 16 : bool bRet = false;
260 :
261 16 : if ( GetModel().is() )
262 16 : bRet = implImport( rDescriptor );
263 :
264 16 : if ( xWindow.is() )
265 : {
266 5 : SolarMutexGuard aGuard;
267 5 : vcl::Window* pFocusWindow = VCLUnoHelper::GetWindow( xWindow );
268 5 : if ( pFocusWindow )
269 5 : pFocusWindow->LeaveWait();
270 : }
271 :
272 16 : return bRet;
273 : }
274 :
275 16 : bool ODBFilter::implImport( const Sequence< PropertyValue >& rDescriptor )
276 : throw (RuntimeException)
277 : {
278 16 : OUString sFileName;
279 32 : ::comphelper::NamedValueCollection aMediaDescriptor( rDescriptor );
280 :
281 32 : uno::Reference<embed::XStorage> xStorage = GetSourceStorage();
282 :
283 16 : bool bRet = true;
284 16 : if (!xStorage.is())
285 : {
286 16 : if (aMediaDescriptor.has("URL"))
287 16 : sFileName = aMediaDescriptor.getOrDefault("URL", OUString());
288 16 : if (sFileName.isEmpty() && aMediaDescriptor.has("FileName"))
289 0 : sFileName = aMediaDescriptor.getOrDefault("FileName", sFileName);
290 :
291 : OSL_ENSURE(!sFileName.isEmpty(), "ODBFilter::implImport: no URL given!");
292 16 : bRet = !sFileName.isEmpty();
293 : }
294 :
295 16 : if ( bRet )
296 : {
297 16 : uno::Reference<XComponent> xCom(GetModel(),UNO_QUERY);
298 :
299 32 : SfxMediumRef pMedium(0);
300 16 : if (!xStorage.is())
301 : {
302 16 : OUString sStreamRelPath;
303 16 : if (sFileName.startsWithIgnoreAsciiCase("vnd.sun.star.pkg:"))
304 : {
305 : // In this case the host contains the real path, and the path is the embedded stream name.
306 1 : INetURLObject aURL(sFileName);
307 1 : sFileName = aURL.GetHost(INetURLObject::DECODE_WITH_CHARSET);
308 1 : sStreamRelPath = aURL.GetURLPath(INetURLObject::DECODE_WITH_CHARSET);
309 1 : if (sStreamRelPath.startsWith("/"))
310 1 : sStreamRelPath = sStreamRelPath.copy(1);
311 : }
312 :
313 16 : pMedium = new SfxMedium(sFileName, (StreamMode::READ | StreamMode::NOCREATE));
314 : try
315 : {
316 16 : xStorage.set(pMedium->GetStorage(false), UNO_QUERY_THROW);
317 :
318 16 : if (!sStreamRelPath.isEmpty())
319 1 : xStorage = xStorage->openStorageElement(sStreamRelPath, embed::ElementModes::READ);
320 : }
321 0 : catch (const Exception&)
322 : {
323 0 : Any aError = ::cppu::getCaughtException();
324 0 : if (aError.isExtractableTo(::cppu::UnoType<RuntimeException>::get()))
325 0 : throw;
326 0 : throw lang::WrappedTargetRuntimeException(OUString(), *this, aError);
327 16 : }
328 : }
329 :
330 32 : uno::Reference<sdb::XOfficeDatabaseDocument> xOfficeDoc(GetModel(),UNO_QUERY_THROW);
331 16 : m_xDataSource.set(xOfficeDoc->getDataSource(),UNO_QUERY_THROW);
332 32 : uno::Reference< XNumberFormatsSupplier > xNum(m_xDataSource->getPropertyValue(PROPERTY_NUMBERFORMATSSUPPLIER),UNO_QUERY);
333 16 : SetNumberFormatsSupplier(xNum);
334 :
335 32 : uno::Reference<XComponent> xModel(GetModel(),UNO_QUERY);
336 : sal_Int32 nRet = ReadThroughComponent( xStorage
337 : ,xModel
338 : ,"settings.xml"
339 : ,"Settings.xml"
340 : ,GetComponentContext()
341 : ,this
342 16 : );
343 :
344 16 : if ( nRet == 0 )
345 : nRet = ReadThroughComponent( xStorage
346 : ,xModel
347 : ,"content.xml"
348 : ,"Content.xml"
349 : ,GetComponentContext()
350 : ,this
351 16 : );
352 :
353 16 : bRet = nRet == 0;
354 :
355 16 : if ( bRet )
356 : {
357 16 : uno::Reference< XModifiable > xModi(GetModel(),UNO_QUERY);
358 16 : if ( xModi.is() )
359 16 : xModi->setModified(sal_False);
360 : }
361 : else
362 : {
363 0 : switch( nRet )
364 : {
365 : case ERRCODE_IO_BROKENPACKAGE:
366 : // TODO/LATER: no way to transport the error outside from the filter!
367 0 : break;
368 : default:
369 : {
370 : // TODO/LATER: this is completely wrong! Filter code should never call ErrorHandler directly! But for now this is the only way!
371 0 : ErrorHandler::HandleError( nRet );
372 0 : if( nRet & ERRCODE_WARNING_MASK )
373 0 : bRet = true;
374 : }
375 : }
376 16 : }
377 : }
378 :
379 32 : return bRet;
380 : }
381 :
382 128 : SvXMLImportContext* ODBFilter::CreateContext( sal_uInt16 nPrefix,
383 : const OUString& rLocalName,
384 : const uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList )
385 : {
386 128 : SvXMLImportContext *pContext = 0;
387 :
388 128 : const SvXMLTokenMap& rTokenMap = GetDocElemTokenMap();
389 128 : switch( rTokenMap.Get( nPrefix, rLocalName ) )
390 : {
391 : case XML_TOK_DOC_SETTINGS:
392 4 : GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP );
393 4 : pContext = new XMLDocumentSettingsContext( *this, nPrefix, rLocalName,xAttrList );
394 4 : break;
395 : case XML_TOK_DOC_DATABASE:
396 16 : GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP );
397 16 : pContext = new OXMLDatabase( *this, nPrefix, rLocalName );
398 16 : break;
399 : case XML_TOK_DOC_STYLES:
400 0 : GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP );
401 0 : pContext = CreateStylesContext(nPrefix, rLocalName, xAttrList, false);
402 0 : break;
403 : case XML_TOK_DOC_AUTOSTYLES:
404 16 : GetProgressBarHelper()->Increment( PROGRESS_BAR_STEP );
405 16 : pContext = CreateStylesContext(nPrefix, rLocalName, xAttrList, true);
406 16 : break;
407 : case XML_TOK_DOC_SCRIPT:
408 16 : pContext = CreateScriptContext( rLocalName );
409 16 : break;
410 : }
411 :
412 128 : if ( !pContext )
413 76 : pContext = SvXMLImport::CreateContext( nPrefix, rLocalName, xAttrList );
414 :
415 128 : return pContext;
416 : }
417 :
418 4 : void ODBFilter::SetViewSettings(const Sequence<PropertyValue>& aViewProps)
419 : {
420 4 : const PropertyValue *pIter = aViewProps.getConstArray();
421 4 : const PropertyValue *pEnd = pIter + aViewProps.getLength();
422 8 : for (; pIter != pEnd; ++pIter)
423 : {
424 4 : if ( pIter->Name == "Queries" )
425 : {
426 4 : fillPropertyMap(pIter->Value,m_aQuerySettings);
427 : }
428 0 : else if ( pIter->Name == "Tables" )
429 : {
430 0 : fillPropertyMap(pIter->Value,m_aTablesSettings);
431 : }
432 : }
433 4 : }
434 :
435 0 : void ODBFilter::SetConfigurationSettings(const Sequence<PropertyValue>& aConfigProps)
436 : {
437 0 : const PropertyValue *pIter = aConfigProps.getConstArray();
438 0 : const PropertyValue *pEnd = pIter + aConfigProps.getLength();
439 0 : for (; pIter != pEnd; ++pIter)
440 : {
441 0 : if ( pIter->Name == "layout-settings" )
442 : {
443 0 : Sequence<PropertyValue> aWindows;
444 0 : pIter->Value >>= aWindows;
445 0 : uno::Reference<XPropertySet> xProp(getDataSource());
446 0 : if ( xProp.is() )
447 0 : xProp->setPropertyValue(PROPERTY_LAYOUTINFORMATION,makeAny(aWindows));
448 : }
449 : }
450 0 : }
451 :
452 4 : void ODBFilter::fillPropertyMap(const Any& _rValue,TPropertyNameMap& _rMap)
453 : {
454 4 : Sequence<PropertyValue> aWindows;
455 4 : _rValue >>= aWindows;
456 4 : const PropertyValue *pIter = aWindows.getConstArray();
457 4 : const PropertyValue *pEnd = pIter + aWindows.getLength();
458 4 : for (; pIter != pEnd; ++pIter)
459 : {
460 0 : Sequence<PropertyValue> aValue;
461 0 : pIter->Value >>= aValue;
462 0 : _rMap.insert(TPropertyNameMap::value_type(pIter->Name,aValue));
463 4 : }
464 :
465 4 : }
466 :
467 128 : const SvXMLTokenMap& ODBFilter::GetDocElemTokenMap() const
468 : {
469 128 : if ( !m_pDocElemTokenMap.get() )
470 : {
471 : static const SvXMLTokenMapEntry aElemTokenMap[]=
472 : {
473 : { XML_NAMESPACE_OFFICE, XML_SETTINGS, XML_TOK_DOC_SETTINGS },
474 : { XML_NAMESPACE_OOO, XML_SETTINGS, XML_TOK_DOC_SETTINGS },
475 : { XML_NAMESPACE_OFFICE, XML_STYLES, XML_TOK_DOC_STYLES },
476 : { XML_NAMESPACE_OOO, XML_STYLES, XML_TOK_DOC_STYLES },
477 : { XML_NAMESPACE_OFFICE, XML_AUTOMATIC_STYLES, XML_TOK_DOC_AUTOSTYLES },
478 : { XML_NAMESPACE_OOO, XML_AUTOMATIC_STYLES, XML_TOK_DOC_AUTOSTYLES },
479 : { XML_NAMESPACE_OFFICE, XML_DATABASE, XML_TOK_DOC_DATABASE },
480 : { XML_NAMESPACE_OOO, XML_DATABASE, XML_TOK_DOC_DATABASE },
481 : { XML_NAMESPACE_OFFICE, XML_SCRIPTS, XML_TOK_DOC_SCRIPT },
482 : XML_TOKEN_MAP_END
483 : };
484 16 : m_pDocElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
485 : }
486 128 : return *m_pDocElemTokenMap;
487 : }
488 :
489 36 : const SvXMLTokenMap& ODBFilter::GetDatabaseElemTokenMap() const
490 : {
491 36 : if ( !m_pDatabaseElemTokenMap.get() )
492 : {
493 : static const SvXMLTokenMapEntry aElemTokenMap[]=
494 : {
495 : { XML_NAMESPACE_DB, XML_DATASOURCE, XML_TOK_DATASOURCE },
496 : { XML_NAMESPACE_DB, XML_FORMS, XML_TOK_FORMS},
497 : { XML_NAMESPACE_DB, XML_REPORTS, XML_TOK_REPORTS},
498 : { XML_NAMESPACE_DB, XML_QUERIES, XML_TOK_QUERIES},
499 : { XML_NAMESPACE_DB, XML_TABLES, XML_TOK_TABLES},
500 : { XML_NAMESPACE_DB, XML_TABLE_REPRESENTATIONS, XML_TOK_TABLES},
501 : { XML_NAMESPACE_DB, XML_SCHEMA_DEFINITION, XML_TOK_SCHEMA_DEFINITION},
502 : XML_TOKEN_MAP_END
503 : };
504 16 : m_pDatabaseElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
505 : }
506 36 : return *m_pDatabaseElemTokenMap;
507 : }
508 :
509 160 : const SvXMLTokenMap& ODBFilter::GetDataSourceElemTokenMap() const
510 : {
511 160 : if ( !m_pDataSourceElemTokenMap.get() )
512 : {
513 : static const SvXMLTokenMapEntry aElemTokenMap[]=
514 : {
515 : { XML_NAMESPACE_DB, XML_CONNECTION_RESOURCE, XML_TOK_CONNECTION_RESOURCE},
516 : { XML_NAMESPACE_DB, XML_SUPPRESS_VERSION_COLUMNS, XML_TOK_SUPPRESS_VERSION_COLUMNS},
517 : { XML_NAMESPACE_DB, XML_JAVA_DRIVER_CLASS, XML_TOK_JAVA_DRIVER_CLASS},
518 : { XML_NAMESPACE_DB, XML_EXTENSION, XML_TOK_EXTENSION},
519 : { XML_NAMESPACE_DB, XML_IS_FIRST_ROW_HEADER_LINE, XML_TOK_IS_FIRST_ROW_HEADER_LINE},
520 : { XML_NAMESPACE_DB, XML_SHOW_DELETED, XML_TOK_SHOW_DELETED},
521 : { XML_NAMESPACE_DB, XML_IS_TABLE_NAME_LENGTH_LIMITED, XML_TOK_IS_TABLE_NAME_LENGTH_LIMITED},
522 : { XML_NAMESPACE_DB, XML_SYSTEM_DRIVER_SETTINGS, XML_TOK_SYSTEM_DRIVER_SETTINGS},
523 : { XML_NAMESPACE_DB, XML_ENABLE_SQL92_CHECK, XML_TOK_ENABLE_SQL92_CHECK},
524 : { XML_NAMESPACE_DB, XML_APPEND_TABLE_ALIAS_NAME, XML_TOK_APPEND_TABLE_ALIAS_NAME},
525 : { XML_NAMESPACE_DB, XML_PARAMETER_NAME_SUBSTITUTION, XML_TOK_PARAMETER_NAME_SUBSTITUTION},
526 : { XML_NAMESPACE_DB, XML_IGNORE_DRIVER_PRIVILEGES, XML_TOK_IGNORE_DRIVER_PRIVILEGES},
527 : { XML_NAMESPACE_DB, XML_BOOLEAN_COMPARISON_MODE, XML_TOK_BOOLEAN_COMPARISON_MODE},
528 : { XML_NAMESPACE_DB, XML_USE_CATALOG, XML_TOK_USE_CATALOG},
529 : { XML_NAMESPACE_DB, XML_BASE_DN, XML_TOK_BASE_DN},
530 : { XML_NAMESPACE_DB, XML_MAX_ROW_COUNT, XML_TOK_MAX_ROW_COUNT},
531 : { XML_NAMESPACE_DB, XML_LOGIN, XML_TOK_LOGIN},
532 : { XML_NAMESPACE_DB, XML_TABLE_FILTER, XML_TOK_TABLE_FILTER},
533 : { XML_NAMESPACE_DB, XML_TABLE_TYPE_FILTER, XML_TOK_TABLE_TYPE_FILTER},
534 : { XML_NAMESPACE_DB, XML_AUTO_INCREMENT, XML_TOK_AUTO_INCREMENT},
535 : { XML_NAMESPACE_DB, XML_DELIMITER, XML_TOK_DELIMITER},
536 : { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTINGS, XML_TOK_DATA_SOURCE_SETTINGS},
537 : { XML_NAMESPACE_DB, XML_FONT_CHARSET, XML_TOK_FONT_CHARSET},
538 : // db odf 12
539 : { XML_NAMESPACE_DB, XML_CONNECTION_DATA, XML_TOK_CONNECTION_DATA},
540 : { XML_NAMESPACE_DB, XML_DATABASE_DESCRIPTION, XML_TOK_DATABASE_DESCRIPTION},
541 : { XML_NAMESPACE_DB, XML_COMPOUND_DATABASE, XML_TOK_COMPOUND_DATABASE},
542 : { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_DB_HREF},
543 : { XML_NAMESPACE_DB, XML_MEDIA_TYPE, XML_TOK_MEDIA_TYPE},
544 : { XML_NAMESPACE_DB, XML_TYPE, XML_TOK_DB_TYPE},
545 : { XML_NAMESPACE_DB, XML_HOSTNAME, XML_TOK_HOSTNAME},
546 : { XML_NAMESPACE_DB, XML_PORT, XML_TOK_PORT},
547 : { XML_NAMESPACE_DB, XML_LOCAL_SOCKET, XML_TOK_LOCAL_SOCKET},
548 : { XML_NAMESPACE_DB, XML_DATABASE_NAME, XML_TOK_DATABASE_NAME},
549 : { XML_NAMESPACE_DB, XML_DRIVER_SETTINGS, XML_TOK_DRIVER_SETTINGS},
550 : { XML_NAMESPACE_DB, XML_JAVA_CLASSPATH, XML_TOK_JAVA_CLASSPATH},
551 : { XML_NAMESPACE_DB, XML_CHARACTER_SET, XML_TOK_CHARACTER_SET},
552 : { XML_NAMESPACE_DB, XML_APPLICATION_CONNECTION_SETTINGS,XML_TOK_APPLICATION_CONNECTION_SETTINGS},
553 : XML_TOKEN_MAP_END
554 : };
555 16 : m_pDataSourceElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
556 : }
557 160 : return *m_pDataSourceElemTokenMap;
558 : }
559 :
560 16 : const SvXMLTokenMap& ODBFilter::GetLoginElemTokenMap() const
561 : {
562 16 : if ( !m_pLoginElemTokenMap.get() )
563 : {
564 : static const SvXMLTokenMapEntry aElemTokenMap[]=
565 : {
566 : { XML_NAMESPACE_DB, XML_USER_NAME, XML_TOK_USER_NAME},
567 : { XML_NAMESPACE_DB, XML_IS_PASSWORD_REQUIRED, XML_TOK_IS_PASSWORD_REQUIRED},
568 : { XML_NAMESPACE_DB, XML_USE_SYSTEM_USER, XML_TOK_USE_SYSTEM_USER},
569 : { XML_NAMESPACE_DB, XML_LOGIN_TIMEOUT, XML_TOK_LOGIN_TIMEOUT},
570 : XML_TOKEN_MAP_END
571 : };
572 16 : m_pLoginElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
573 : }
574 16 : return *m_pLoginElemTokenMap;
575 : }
576 :
577 9 : const SvXMLTokenMap& ODBFilter::GetDatabaseDescriptionElemTokenMap() const
578 : {
579 9 : if ( !m_pDatabaseDescriptionElemTokenMap.get() )
580 : {
581 : static const SvXMLTokenMapEntry aElemTokenMap[]=
582 : {
583 : { XML_NAMESPACE_DB, XML_FILE_BASED_DATABASE, XML_TOK_FILE_BASED_DATABASE},
584 : { XML_NAMESPACE_DB, XML_SERVER_DATABASE, XML_TOK_SERVER_DATABASE},
585 : XML_TOKEN_MAP_END
586 : };
587 9 : m_pDatabaseDescriptionElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
588 : }
589 9 : return *m_pDatabaseDescriptionElemTokenMap;
590 : }
591 :
592 7 : const SvXMLTokenMap& ODBFilter::GetDataSourceInfoElemTokenMap() const
593 : {
594 7 : if ( !m_pDataSourceInfoElemTokenMap.get() )
595 : {
596 : static const SvXMLTokenMapEntry aElemTokenMap[]=
597 : {
598 : { XML_NAMESPACE_DB, XML_ADDITIONAL_COLUMN_STATEMENT,XML_TOK_ADDITIONAL_COLUMN_STATEMENT},
599 : { XML_NAMESPACE_DB, XML_ROW_RETRIEVING_STATEMENT, XML_TOK_ROW_RETRIEVING_STATEMENT},
600 : { XML_NAMESPACE_DB, XML_STRING, XML_TOK_STRING},
601 : { XML_NAMESPACE_DB, XML_FIELD, XML_TOK_FIELD},
602 : { XML_NAMESPACE_DB, XML_DECIMAL, XML_TOK_DECIMAL},
603 : { XML_NAMESPACE_DB, XML_THOUSAND, XML_TOK_THOUSAND},
604 : { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING, XML_TOK_DATA_SOURCE_SETTING},
605 : { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING_VALUE, XML_TOK_DATA_SOURCE_SETTING_VALUE},
606 : { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING_IS_LIST,XML_TOK_DATA_SOURCE_SETTING_IS_LIST},
607 : { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING_TYPE, XML_TOK_DATA_SOURCE_SETTING_TYPE},
608 : { XML_NAMESPACE_DB, XML_DATA_SOURCE_SETTING_NAME, XML_TOK_DATA_SOURCE_SETTING_NAME},
609 : { XML_NAMESPACE_DB, XML_FONT_CHARSET, XML_TOK_FONT_CHARSET},
610 : { XML_NAMESPACE_DB, XML_ENCODING, XML_TOK_ENCODING},
611 : XML_TOKEN_MAP_END
612 : };
613 7 : m_pDataSourceInfoElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
614 : }
615 7 : return *m_pDataSourceInfoElemTokenMap;
616 : }
617 :
618 244 : const SvXMLTokenMap& ODBFilter::GetDocumentsElemTokenMap() const
619 : {
620 244 : if ( !m_pDocumentsElemTokenMap.get() )
621 : {
622 : static const SvXMLTokenMapEntry aElemTokenMap[]=
623 : {
624 : { XML_NAMESPACE_DB, XML_COMPONENT, XML_TOK_COMPONENT},
625 : { XML_NAMESPACE_DB, XML_COMPONENT_COLLECTION, XML_TOK_COMPONENT_COLLECTION},
626 : { XML_NAMESPACE_DB, XML_QUERY_COLLECTION, XML_TOK_QUERY_COLLECTION},
627 : { XML_NAMESPACE_DB, XML_QUERY, XML_TOK_QUERY},
628 : { XML_NAMESPACE_DB, XML_TABLE, XML_TOK_TABLE},
629 : { XML_NAMESPACE_DB, XML_TABLE_REPRESENTATION, XML_TOK_TABLE},
630 : { XML_NAMESPACE_DB, XML_COLUMN, XML_TOK_COLUMN},
631 : XML_TOKEN_MAP_END
632 : };
633 12 : m_pDocumentsElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
634 : }
635 244 : return *m_pDocumentsElemTokenMap;
636 : }
637 :
638 15 : const SvXMLTokenMap& ODBFilter::GetComponentElemTokenMap() const
639 : {
640 15 : if ( !m_pComponentElemTokenMap.get() )
641 : {
642 : static const SvXMLTokenMapEntry aElemTokenMap[]=
643 : {
644 : { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_HREF },
645 : { XML_NAMESPACE_XLINK, XML_TYPE, XML_TOK_TYPE },
646 : { XML_NAMESPACE_XLINK, XML_SHOW, XML_TOK_SHOW },
647 : { XML_NAMESPACE_XLINK, XML_ACTUATE, XML_TOK_ACTUATE},
648 : { XML_NAMESPACE_DB, XML_AS_TEMPLATE, XML_TOK_AS_TEMPLATE },
649 : { XML_NAMESPACE_DB, XML_NAME, XML_TOK_COMPONENT_NAME },
650 : XML_TOKEN_MAP_END
651 : };
652 7 : m_pComponentElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
653 : }
654 15 : return *m_pComponentElemTokenMap;
655 : }
656 :
657 49 : const SvXMLTokenMap& ODBFilter::GetQueryElemTokenMap() const
658 : {
659 49 : if ( !m_pQueryElemTokenMap.get() )
660 : {
661 : static const SvXMLTokenMapEntry aElemTokenMap[]=
662 : {
663 : { XML_NAMESPACE_DB, XML_COMMAND, XML_TOK_COMMAND },
664 : { XML_NAMESPACE_DB, XML_ESCAPE_PROCESSING, XML_TOK_ESCAPE_PROCESSING },
665 : { XML_NAMESPACE_DB, XML_NAME, XML_TOK_QUERY_NAME },
666 : { XML_NAMESPACE_DB, XML_FILTER_STATEMENT, XML_TOK_FILTER_STATEMENT },
667 : { XML_NAMESPACE_DB, XML_ORDER_STATEMENT, XML_TOK_ORDER_STATEMENT },
668 : { XML_NAMESPACE_DB, XML_CATALOG_NAME, XML_TOK_CATALOG_NAME },
669 : { XML_NAMESPACE_DB, XML_SCHEMA_NAME, XML_TOK_SCHEMA_NAME },
670 : { XML_NAMESPACE_DB, XML_STYLE_NAME, XML_TOK_STYLE_NAME},
671 : { XML_NAMESPACE_DB, XML_APPLY_FILTER, XML_TOK_APPLY_FILTER},
672 : { XML_NAMESPACE_DB, XML_APPLY_ORDER, XML_TOK_APPLY_ORDER},
673 : { XML_NAMESPACE_DB, XML_COLUMNS, XML_TOK_COLUMNS},
674 : XML_TOKEN_MAP_END
675 : };
676 12 : m_pQueryElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
677 : }
678 49 : return *m_pQueryElemTokenMap;
679 : }
680 :
681 213 : const SvXMLTokenMap& ODBFilter::GetColumnElemTokenMap() const
682 : {
683 213 : if ( !m_pColumnElemTokenMap.get() )
684 : {
685 : static const SvXMLTokenMapEntry aElemTokenMap[]=
686 : {
687 : { XML_NAMESPACE_DB, XML_NAME, XML_TOK_COLUMN_NAME },
688 : { XML_NAMESPACE_DB, XML_STYLE_NAME, XML_TOK_COLUMN_STYLE_NAME },
689 : { XML_NAMESPACE_DB, XML_HELP_MESSAGE, XML_TOK_COLUMN_HELP_MESSAGE },
690 : { XML_NAMESPACE_DB, XML_VISIBILITY, XML_TOK_COLUMN_VISIBILITY },
691 : { XML_NAMESPACE_DB, XML_DEFAULT_VALUE, XML_TOK_COLUMN_DEFAULT_VALUE },
692 : { XML_NAMESPACE_DB, XML_TYPE_NAME, XML_TOK_COLUMN_TYPE_NAME },
693 : { XML_NAMESPACE_DB, XML_VISIBLE, XML_TOK_COLUMN_VISIBLE },
694 : { XML_NAMESPACE_DB, XML_DEFAULT_CELL_STYLE_NAME, XML_TOK_DEFAULT_CELL_STYLE_NAME },
695 : XML_TOKEN_MAP_END
696 : };
697 8 : m_pColumnElemTokenMap.reset(new SvXMLTokenMap( aElemTokenMap ));
698 : }
699 213 : return *m_pColumnElemTokenMap;
700 : }
701 :
702 16 : SvXMLImportContext* ODBFilter::CreateStylesContext(sal_uInt16 _nPrefix,const OUString& rLocalName,
703 : const uno::Reference< XAttributeList>& xAttrList, bool bIsAutoStyle )
704 : {
705 16 : SvXMLImportContext *pContext = NULL;
706 16 : if (!pContext)
707 : {
708 16 : pContext = new OTableStylesContext(*this, _nPrefix, rLocalName, xAttrList, bIsAutoStyle);
709 16 : if (bIsAutoStyle)
710 16 : SetAutoStyles(static_cast<SvXMLStylesContext*>(pContext));
711 : else
712 0 : SetStyles(static_cast<SvXMLStylesContext*>(pContext));
713 : }
714 16 : return pContext;
715 : }
716 :
717 16 : SvXMLImportContext* ODBFilter::CreateScriptContext( const OUString& _rLocalName )
718 : {
719 16 : return new XMLScriptContext( *this, XML_NAMESPACE_OFFICE, _rLocalName, GetModel() );
720 : }
721 :
722 0 : rtl::Reference < XMLPropertySetMapper > ODBFilter::GetTableStylesPropertySetMapper() const
723 : {
724 0 : if ( !m_xTableStylesPropertySetMapper.is() )
725 : {
726 0 : m_xTableStylesPropertySetMapper = OXMLHelper::GetTableStylesPropertySetMapper( false);
727 : }
728 0 : return m_xTableStylesPropertySetMapper;
729 : }
730 :
731 8 : rtl::Reference < XMLPropertySetMapper > ODBFilter::GetColumnStylesPropertySetMapper() const
732 : {
733 8 : if ( !m_xColumnStylesPropertySetMapper.is() )
734 : {
735 8 : m_xColumnStylesPropertySetMapper = OXMLHelper::GetColumnStylesPropertySetMapper( false);
736 : }
737 8 : return m_xColumnStylesPropertySetMapper;
738 : }
739 :
740 8 : rtl::Reference < XMLPropertySetMapper > ODBFilter::GetCellStylesPropertySetMapper() const
741 : {
742 8 : if ( !m_xCellStylesPropertySetMapper.is() )
743 : {
744 8 : m_xCellStylesPropertySetMapper = OXMLHelper::GetCellStylesPropertySetMapper( false);
745 : }
746 8 : return m_xCellStylesPropertySetMapper;
747 : }
748 :
749 16 : void ODBFilter::setPropertyInfo()
750 : {
751 16 : Reference<XPropertySet> xDataSource(getDataSource());
752 16 : if ( !xDataSource.is() )
753 16 : return;
754 :
755 32 : ::connectivity::DriversConfig aDriverConfig(GetComponentContext());
756 32 : const OUString sURL = ::comphelper::getString(xDataSource->getPropertyValue(PROPERTY_URL));
757 32 : ::comphelper::NamedValueCollection aDataSourceSettings = aDriverConfig.getProperties( sURL );
758 :
759 32 : Sequence<PropertyValue> aInfo;
760 16 : if ( !m_aInfoSequence.empty() )
761 16 : aInfo = Sequence<PropertyValue>(&(*m_aInfoSequence.begin()),m_aInfoSequence.size());
762 16 : aDataSourceSettings.merge( ::comphelper::NamedValueCollection( aInfo ), true );
763 :
764 16 : aDataSourceSettings >>= aInfo;
765 16 : if ( aInfo.getLength() )
766 : {
767 : try
768 : {
769 16 : xDataSource->setPropertyValue(PROPERTY_INFO,makeAny(aInfo));
770 : }
771 0 : catch (const Exception&)
772 : {
773 : DBG_UNHANDLED_EXCEPTION();
774 : }
775 16 : }
776 : }
777 :
778 : }// dbaxml
779 :
780 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
