xref: /trunk/main/sd/source/filter/sddetect.cxx (revision b63233d8)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sd.hxx"
26 
27 #include <com/sun/star/document/XExtendedFilterDetection.hpp>
28 #include <com/sun/star/uno/Exception.hpp>
29 #include <com/sun/star/uno/Reference.h>
30 #include <com/sun/star/lang/XServiceInfo.hpp>
31 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
32 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
33 #include <com/sun/star/beans/PropertyValue.hpp>
34 #include <com/sun/star/io/XInputStream.hpp>
35 #include <com/sun/star/task/XInteractionHandler.hpp>
36 #include <com/sun/star/ucb/InteractiveAppException.hpp>
37 #include <com/sun/star/ucb/XContent.hpp>
38 #include <com/sun/star/packages/zip/ZipIOException.hpp>
39 
40 #include <vos/mutex.hxx>
41 
42 #include <cppuhelper/implbase2.hxx>
43 #include <cppuhelper/factory.hxx>
44 #include <ucbhelper/simpleinteractionrequest.hxx>
45 
46 #include <comphelper/processfactory.hxx>
47 
48 #include <tools/urlobj.hxx>
49 
50 #include <framework/interaction.hxx>
51 
52 #include <svl/itemset.hxx>
53 #include <svl/eitem.hxx>
54 #include <svl/stritem.hxx>
55 
56 #include <svtools/filter.hxx>
57 #include <svtools/sfxecode.hxx>
58 #include <svtools/ehdl.hxx>
59 #include <svtools/FilterConfigItem.hxx>
60 
61 #include <sot/storinfo.hxx>
62 #include <sot/storage.hxx>
63 
64 #include <unotools/moduleoptions.hxx>
65 
66 #include <sfx2/app.hxx>
67 #include <sfx2/sfxsids.hrc>
68 #include <sfx2/request.hxx>
69 #include <sfx2/docfile.hxx>
70 #include <sfx2/fcontnr.hxx>
71 #include <sfx2/brokenpackageint.hxx>
72 
73 #include "strmname.h"
74 
75 using ::rtl::OUString;
76 
77 using namespace ::com::sun::star::uno;
78 using namespace ::com::sun::star::io;
79 using namespace ::com::sun::star::frame;
80 using namespace ::com::sun::star::embed;
81 using namespace ::com::sun::star::task;
82 using namespace ::com::sun::star::beans;
83 using namespace ::com::sun::star::lang;
84 using namespace ::com::sun::star::ucb;
85 
86 class SdFilterDetect : public ::cppu::WeakImplHelper2< ::com::sun::star::document::XExtendedFilterDetection, XServiceInfo >
87 {
88 public:
89 	SdFilterDetect( const Reference < XMultiServiceFactory >& xFactory );
90 	virtual ~SdFilterDetect();
91 
92     virtual OUString SAL_CALL getImplementationName(  ) throw (RuntimeException);
93     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) throw (RuntimeException);
94     virtual Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) throw (RuntimeException);
95 
96 	static Sequence< OUString > impl_getStaticSupportedServiceNames();
97 	static OUString impl_getStaticImplementationName();
98 	static Reference< XInterface > SAL_CALL impl_createInstance( const Reference< XMultiServiceFactory >& xServiceManager ) throw( Exception );
99 	virtual OUString SAL_CALL detect( Sequence< PropertyValue >& lDescriptor ) throw( RuntimeException );
100 };
101 
SdFilterDetect(const Reference<XMultiServiceFactory> &)102 SdFilterDetect::SdFilterDetect( const Reference < XMultiServiceFactory >&  )
103 {
104 }
105 
~SdFilterDetect()106 SdFilterDetect::~SdFilterDetect()
107 {
108 }
109 
detect(Sequence<PropertyValue> & lDescriptor)110 OUString SAL_CALL SdFilterDetect::detect( Sequence< PropertyValue >& lDescriptor ) throw( RuntimeException )
111 {
112 	Reference< XInputStream > xStream;
113 	Reference< XContent > xContent;
114 	Reference< XInteractionHandler > xInteraction;
115 	String aURL;
116 	OUString sTemp;
117 	String aTypeName;            // a name describing the type (from MediaDescriptor, usually from flat detection)
118 	String aPreselectedFilterName;      // a name describing the filter to use (from MediaDescriptor, usually from UI action)
119 
120 	OUString aDocumentTitle; // interesting only if set in this method
121 
122 	// opening as template is done when a parameter tells to do so and a template filter can be detected
123 	// (otherwise no valid filter would be found) or if the detected filter is a template filter and
124 	// there is no parameter that forbids to open as template
125 	sal_Bool bOpenAsTemplate = sal_False;
126 	sal_Bool bWasReadOnly = sal_False, bReadOnly = sal_False;
127 
128 	sal_Bool bRepairPackage = sal_False;
129 	sal_Bool bRepairAllowed = sal_False;
130 
131 	// now some parameters that can already be in the array, but may be overwritten or new inserted here
132 	// remember their indices in the case new values must be added to the array
133 	sal_Int32 nPropertyCount = lDescriptor.getLength();
134 	sal_Int32 nIndexOfFilterName = -1;
135 	sal_Int32 nIndexOfInputStream = -1;
136 	sal_Int32 nIndexOfContent = -1;
137 	sal_Int32 nIndexOfReadOnlyFlag = -1;
138 	sal_Int32 nIndexOfTemplateFlag = -1;
139 	sal_Int32 nIndexOfDocumentTitle = -1;
140 
141 	for( sal_Int32 nProperty=0; nProperty<nPropertyCount; ++nProperty )
142 	{
143 		// extract properties
144 		if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("URL")) )
145 		{
146 			lDescriptor[nProperty].Value >>= sTemp;
147 			aURL = sTemp;
148 		}
149 		else if( !aURL.Len() && lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("FileName")) )
150 		{
151 			lDescriptor[nProperty].Value >>= sTemp;
152 			aURL = sTemp;
153 		}
154 		else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("TypeName")) )
155 		{
156 			lDescriptor[nProperty].Value >>= sTemp;
157 			aTypeName = sTemp;
158 		}
159 		else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("FilterName")) )
160 		{
161 			lDescriptor[nProperty].Value >>= sTemp;
162 			aPreselectedFilterName = sTemp;
163 
164 			// if the preselected filter name is not correct, it must be erased after detection
165 			// remember index of property to get access to it later
166 			nIndexOfFilterName = nProperty;
167 		}
168 		else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("InputStream")) )
169 			nIndexOfInputStream = nProperty;
170 		else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("ReadOnly")) )
171 			nIndexOfReadOnlyFlag = nProperty;
172 		else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("UCBContent")) )
173 			nIndexOfContent = nProperty;
174 		else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("AsTemplate")) )
175 		{
176 			lDescriptor[nProperty].Value >>= bOpenAsTemplate;
177 			nIndexOfTemplateFlag = nProperty;
178 		}
179 		else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("InteractionHandler")) )
180 			lDescriptor[nProperty].Value >>= xInteraction;
181 		else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("RepairPackage")) )
182 			lDescriptor[nProperty].Value >>= bRepairPackage;
183 		else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("DocumentTitle")) )
184 			nIndexOfDocumentTitle = nProperty;
185 	}
186 
187 	// can't check the type for external filters, so set the "dont" flag accordingly
188 	::vos::OGuard aGuard( Application::GetSolarMutex() );
189 	//SfxFilterFlags nMust = SFX_FILTER_IMPORT, nDont = SFX_FILTER_NOTINSTALLED;
190 
191 	SfxApplication* pApp = SFX_APP();
192 	SfxAllItemSet *pSet = new SfxAllItemSet( pApp->GetPool() );
193 	TransformParameters( SID_OPENDOC, lDescriptor, *pSet );
194 	SFX_ITEMSET_ARG( pSet, pItem, SfxBoolItem, SID_DOC_READONLY, sal_False );
195 
196 	bWasReadOnly = pItem && pItem->GetValue();
197 
198 	const SfxFilter* pFilter = 0;
199 	String aFilterName;
200 	String aPrefix = String::CreateFromAscii( "private:factory/" );
201 	if( aURL.Match( aPrefix ) == aPrefix.Len() )
202 	{
203 		if( SvtModuleOptions().IsImpress() )
204 		{
205 			String aPattern( aPrefix );
206 			aPattern += String::CreateFromAscii("simpress");
207 			if ( aURL.Match( aPattern ) >= aPattern.Len() )
208 				pFilter = SfxFilter::GetDefaultFilterFromFactory( aURL );
209 		}
210 
211 		if( !pFilter && SvtModuleOptions().IsDraw() )
212 		{
213 			String aPattern( aPrefix );
214 			aPattern += String::CreateFromAscii("sdraw");
215 			if ( aURL.Match( aPattern ) >= aPattern.Len() )
216 				pFilter = SfxFilter::GetDefaultFilterFromFactory( aURL );
217 		}
218 	}
219 	else
220 	{
221 		// ctor of SfxMedium uses owner transition of ItemSet
222 		SfxMedium aMedium( aURL, bWasReadOnly ? STREAM_STD_READ : STREAM_STD_READWRITE, sal_False, NULL, pSet );
223 		aMedium.UseInteractionHandler( sal_True );
224 		if ( aPreselectedFilterName.Len() )
225 			pFilter = SfxFilter::GetFilterByName( aPreselectedFilterName );
226 		else if( aTypeName.Len() )
227 		{
228 			SfxFilterMatcher aMatch;
229 			pFilter = aMatch.GetFilter4EA( aTypeName );
230 		}
231 
232 		if ( aMedium.GetErrorCode() == ERRCODE_NONE )
233 		{
234 			// remember input stream and content and put them into the descriptor later
235 			// should be done here since later the medium can switch to a version
236 			xStream = aMedium.GetInputStream();
237 			xContent = aMedium.GetContent();
238 			bReadOnly = aMedium.IsReadOnly();
239 			sal_Bool bIsStorage = aMedium.IsStorage();
240 
241 			if (aMedium.GetError() == SVSTREAM_OK)
242 			{
243 				if ( bIsStorage )
244 				{
245 					// PowerPoint needs to be detected via StreamName, all other storage based formats are our own and can
246 					// be detected by the ClipboardId, so except for the PPT filter all filters must have a ClipboardId set
247 					Reference< XStorage > xStorage( aMedium.GetStorage( sal_False ) );
248 
249 					//TODO/LATER: move error handling to central place! (maybe even complete own filters)
250 					if ( aMedium.GetLastStorageCreationState() != ERRCODE_NONE )
251 					{
252 						// error during storage creation means _here_ that the medium
253 						// is broken, but we can not handle it in medium since unpossibility
254 						// to create a storage does not _always_ means that the medium is broken
255 						aMedium.SetError( aMedium.GetLastStorageCreationState(), OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ) );
256 						if ( xInteraction.is() )
257 						{
258 							OUString empty;
259 							try
260 							{
261 								InteractiveAppException xException( empty,
262 									Reference< XInterface >(),
263 									InteractionClassification_ERROR,
264 									aMedium.GetError() );
265 
266 								Reference< XInteractionRequest > xRequest(
267 									new ucbhelper::SimpleInteractionRequest( makeAny( xException ),
268 									ucbhelper::CONTINUATION_APPROVE ) );
269 								xInteraction->handle( xRequest );
270 							}
271 							catch ( Exception & ) {};
272 						}
273 					}
274 					else
275 					{
276 						if ( pFilter && !pFilter->GetFormat() )
277 							// preselected Filter has no ClipboardId -> doesn't match (see comment above)
278 							pFilter = 0;
279 
280 						// the storage must be checked even if filter is already found, since it is deep type detection
281 						// the storage can be corrupted and it will be detected here
282 						try
283 						{
284 							String sFilterName;
285 							if ( pFilter )
286 								sFilterName = pFilter->GetName();
287 							aTypeName = SfxFilter::GetTypeFromStorage( xStorage, pFilter ? pFilter->IsOwnTemplateFormat() : sal_False, &sFilterName );
288 						}
289 						catch( WrappedTargetException& aWrap )
290 						{
291 							com::sun::star::packages::zip::ZipIOException aZipException;
292 							if ( ( aWrap.TargetException >>= aZipException ) && aTypeName.Len() )
293 							{
294 								if ( xInteraction.is() )
295 								{
296 									// the package is broken one
297 									aDocumentTitle = aMedium.GetURLObject().getName(
298 										INetURLObject::LAST_SEGMENT,
299 										true,
300 										INetURLObject::DECODE_WITH_CHARSET );
301 
302 									if ( !bRepairPackage )
303 									{
304 										// ask the user whether he wants to try to repair
305 										RequestPackageReparation aRequest( aDocumentTitle );
306 										xInteraction->handle( aRequest.GetRequest() );
307 										bRepairAllowed = aRequest.isApproved();
308 									}
309 
310 									if ( !bRepairAllowed )
311 									{
312 										// repair either not allowed or not successful
313 										NotifyBrokenPackage aNotifyRequest( aDocumentTitle );
314 										xInteraction->handle( aNotifyRequest.GetRequest() );
315 									}
316 								}
317 
318 								if ( !bRepairAllowed )
319 								{
320 									aTypeName.Erase();
321 									pFilter = 0;
322 								}
323 							}
324 						}
325 						catch( RuntimeException& )
326 						{
327 							throw;
328 						}
329 						catch( Exception& )
330 						{
331 							aTypeName.Erase();
332 							pFilter = 0;
333 						}
334 
335 						if ( !pFilter && aTypeName.Len() )
336 						{
337 							//TODO/LATER: using this method impress is always preferred if no flat detecion has been made
338 							// this should been discussed!
339 							if ( SvtModuleOptions().IsImpress() )
340 								pFilter = SfxFilterMatcher( String::CreateFromAscii("simpress") ).GetFilter4EA( aTypeName );
341 							else if ( SvtModuleOptions().IsDraw() )
342 								pFilter = SfxFilterMatcher( String::CreateFromAscii("sdraw") ).GetFilter4EA( aTypeName );
343 						}
344 					}
345 				}
346 				else
347 				{
348 					SvStream* pStm = aMedium.GetInStream();
349 					if ( !pStm )
350 					{
351 						pFilter = 0;
352 					}
353 					else
354 					{
355 						SotStorageRef aStorage = new SotStorage ( pStm, sal_False );
356 						if ( !aStorage->GetError() )
357 						{
358 							String aStreamName = UniString::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "PowerPoint Document" ) );
359 							if ( aStorage->IsStream( aStreamName ) && SvtModuleOptions().IsImpress() )
360 							{
361 								String aFileName(aMedium.GetName());
362 								aFileName.ToUpperAscii();
363 
364 								if( aFileName.SearchAscii( ".POT" ) == STRING_NOTFOUND )
365 									pFilter = SfxFilter::GetFilterByName( pFilterPowerPoint97);
366 								else
367 									pFilter = SfxFilter::GetFilterByName( pFilterPowerPoint97Template );
368 							}
369 						}
370 						else
371 						{
372 							// Vektorgraphik?
373 							pStm->Seek( STREAM_SEEK_TO_BEGIN );
374 
375 							const String        aFileName( aMedium.GetURLObject().GetMainURL( INetURLObject::NO_DECODE ) );
376 							GraphicDescriptor   aDesc( *pStm, &aFileName );
377 							GraphicFilter*      pGrfFilter = GraphicFilter::GetGraphicFilter();
378 							if( !aDesc.Detect( sal_False ) )
379 							{
380 								pFilter = 0;
381 								if( SvtModuleOptions().IsImpress() )
382 								{
383 									INetURLObject aCheckURL( aFileName );
384 									if( aCheckURL.getExtension().equalsIgnoreAsciiCaseAscii( "cgm" ) )
385 									{
386 										sal_uInt8 n8;
387 										pStm->Seek( STREAM_SEEK_TO_BEGIN );
388 										*pStm >> n8;
389 										if ( ( n8 & 0xf0 ) == 0 )       // we are supporting binary cgm format only, so
390 										{                               // this is a small test to exclude cgm text
391 											const String aName = UniString::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "CGM - Computer Graphics Metafile" ) );
392 											SfxFilterMatcher aMatch( String::CreateFromAscii("simpress") );
393 											pFilter = aMatch.GetFilter4FilterName( aName );
394 										}
395 									}
396 								}
397 							}
398 							else
399 							{
400 								String aShortName( aDesc.GetImportFormatShortName( aDesc.GetFileFormat() ) );
401 								const String aName( pGrfFilter->GetImportFormatTypeName( pGrfFilter->GetImportFormatNumberForShortName( aShortName ) ) );
402 
403 								if ( pFilter && aShortName.EqualsIgnoreCaseAscii( "PCD" ) )    // there is a multiple pcd selection possible
404 								{
405 									sal_Int32 nBase = 2;    // default Base0
406 									String aFilterTypeName( pFilter->GetRealTypeName() );
407 									if ( aFilterTypeName.CompareToAscii( "pcd_Photo_CD_Base4" ) == COMPARE_EQUAL )
408 										nBase = 1;
409 									else if ( aFilterTypeName.CompareToAscii( "pcd_Photo_CD_Base16" ) == COMPARE_EQUAL )
410 										nBase = 0;
411 									String aFilterConfigPath( RTL_CONSTASCII_USTRINGPARAM( "Office.Common/Filter/Graphic/Import/PCD" ) );
412 									FilterConfigItem aFilterConfigItem( aFilterConfigPath );
413 									aFilterConfigItem.WriteInt32( String( RTL_CONSTASCII_USTRINGPARAM( "Resolution" ) ), nBase );
414 								}
415 
416 								SfxFilterMatcher aMatch( String::CreateFromAscii("sdraw") );
417 								pFilter = aMatch.GetFilter4FilterName( aName );
418 							}
419 						}
420 					}
421 				}
422 			}
423 		}
424 	}
425 
426 	if ( nIndexOfInputStream == -1 && xStream.is() )
427 	{
428 		// if input stream wasn't part of the descriptor, now it should be, otherwise the content would be opend twice
429 		lDescriptor.realloc( nPropertyCount + 1 );
430 		lDescriptor[nPropertyCount].Name = OUString::createFromAscii("InputStream");
431 		lDescriptor[nPropertyCount].Value <<= xStream;
432 		nPropertyCount++;
433 	}
434 
435 	if ( nIndexOfContent == -1 && xContent.is() )
436 	{
437 		// if input stream wasn't part of the descriptor, now it should be, otherwise the content would be opend twice
438 		lDescriptor.realloc( nPropertyCount + 1 );
439 		lDescriptor[nPropertyCount].Name = OUString::createFromAscii("UCBContent");
440 		lDescriptor[nPropertyCount].Value <<= xContent;
441 		nPropertyCount++;
442 	}
443 
444 	if ( bReadOnly != bWasReadOnly )
445 	{
446 		if ( nIndexOfReadOnlyFlag == -1 )
447 		{
448 			lDescriptor.realloc( nPropertyCount + 1 );
449 			lDescriptor[nPropertyCount].Name = OUString::createFromAscii("ReadOnly");
450 			lDescriptor[nPropertyCount].Value <<= bReadOnly;
451 			nPropertyCount++;
452 		}
453 		else
454 			lDescriptor[nIndexOfReadOnlyFlag].Value <<= bReadOnly;
455 	}
456 
457 	if ( !bRepairPackage && bRepairAllowed )
458 	{
459 		lDescriptor.realloc( nPropertyCount + 1 );
460 		lDescriptor[nPropertyCount].Name = OUString::createFromAscii("RepairPackage");
461 		lDescriptor[nPropertyCount].Value <<= bRepairAllowed;
462 		nPropertyCount++;
463 
464 		bOpenAsTemplate = sal_True;
465 
466 		// TODO/LATER: set progress bar that should be used
467 	}
468 
469 	if ( bOpenAsTemplate )
470 	{
471 		if ( nIndexOfTemplateFlag == -1 )
472 		{
473 			lDescriptor.realloc( nPropertyCount + 1 );
474 			lDescriptor[nPropertyCount].Name = OUString::createFromAscii("AsTemplate");
475 			lDescriptor[nPropertyCount].Value <<= bOpenAsTemplate;
476 			nPropertyCount++;
477 		}
478 		else
479 			lDescriptor[nIndexOfTemplateFlag].Value <<= bOpenAsTemplate;
480 	}
481 
482 	if ( aDocumentTitle.getLength() )
483 	{
484 		// the title was set here
485 		if ( nIndexOfDocumentTitle == -1 )
486 		{
487 			lDescriptor.realloc( nPropertyCount + 1 );
488 			lDescriptor[nPropertyCount].Name = OUString::createFromAscii("DocumentTitle");
489 			lDescriptor[nPropertyCount].Value <<= aDocumentTitle;
490 			nPropertyCount++;
491 		}
492 		else
493 			lDescriptor[nIndexOfDocumentTitle].Value <<= aDocumentTitle;
494 	}
495 
496 	if ( pFilter )
497 		aTypeName = pFilter->GetTypeName();
498 	else
499 		aTypeName.Erase();
500 
501 	return aTypeName;
502 }
503 
504 /* XServiceInfo */
getImplementationName()505 OUString SAL_CALL SdFilterDetect::getImplementationName() throw( RuntimeException )
506 {
507 	return impl_getStaticImplementationName();
508 }
509 
510 /* XServiceInfo */
supportsService(const OUString & sServiceName)511 sal_Bool SAL_CALL SdFilterDetect::supportsService( const OUString& sServiceName ) throw( RuntimeException )
512 {
513 	Sequence< OUString >  seqServiceNames =   getSupportedServiceNames();
514 	const OUString*          pArray          =   seqServiceNames.getConstArray();
515 	for ( sal_Int32 nCounter=0; nCounter<seqServiceNames.getLength(); nCounter++ )
516 	{
517 		if ( pArray[nCounter] == sServiceName )
518 		{
519 			return sal_True ;
520 		}
521 	}
522 	return sal_False ;
523 }
524 
525 /* XServiceInfo */
getSupportedServiceNames()526 Sequence< OUString > SAL_CALL SdFilterDetect::getSupportedServiceNames() throw( RuntimeException )
527 {
528 	return impl_getStaticSupportedServiceNames();
529 }
530 
531 /* Helper for XServiceInfo */
impl_getStaticSupportedServiceNames()532 Sequence< OUString > SdFilterDetect::impl_getStaticSupportedServiceNames()
533 {
534 	::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
535 	Sequence< OUString > seqServiceNames( 1 );
536 	seqServiceNames.getArray() [0] = OUString::createFromAscii( "com.sun.star.frame.ExtendedTypeDetection"  );
537 	return seqServiceNames ;
538 }
539 
540 /* Helper for XServiceInfo */
impl_getStaticImplementationName()541 OUString SdFilterDetect::impl_getStaticImplementationName()
542 {
543 	return OUString::createFromAscii( "com.sun.star.comp.draw.FormatDetector" );
544 }
545 
546 /* Helper for registry */
impl_createInstance(const Reference<XMultiServiceFactory> & xServiceManager)547 Reference< XInterface > SAL_CALL SdFilterDetect::impl_createInstance( const Reference< XMultiServiceFactory >& xServiceManager ) throw( Exception )
548 {
549 	return Reference< XInterface >( *new SdFilterDetect( xServiceManager ) );
550 }
551 
552 extern "C" {
553 
component_getImplementationEnvironment(const sal_Char ** ppEnvironmentTypeName,uno_Environment **)554 	SAL_DLLPUBLIC_EXPORT void SAL_CALL component_getImplementationEnvironment(
555 		const  sal_Char**   ppEnvironmentTypeName,
556 		uno_Environment**              )
557 	{
558 		*ppEnvironmentTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME ;
559 	}
560 
component_getFactory(const sal_Char * pImplementationName,void * pServiceManager,void *)561 	SAL_DLLPUBLIC_EXPORT void* SAL_CALL component_getFactory(
562 		const sal_Char* pImplementationName,
563 		void* pServiceManager,
564 		void*  )
565 	{
566 		// Set default return value for this operation - if it failed.
567 		void* pReturn = NULL ;
568 
569 		if	(
570 			( pImplementationName	!=	NULL ) &&
571 			( pServiceManager		!=	NULL )
572 			)
573 		{
574 			// Define variables which are used in following macros.
575 			Reference< XSingleServiceFactory >   xFactory                                                                                                ;
576 			Reference< XMultiServiceFactory >    xServiceManager( reinterpret_cast< XMultiServiceFactory* >( pServiceManager ) ) ;
577 
578 			if( SdFilterDetect::impl_getStaticImplementationName().equalsAscii( pImplementationName ) )
579 			{
580 				xFactory = ::cppu::createSingleFactory( xServiceManager,
581 					SdFilterDetect::impl_getStaticImplementationName(),
582 					SdFilterDetect::impl_createInstance,
583 					SdFilterDetect::impl_getStaticSupportedServiceNames() );
584 			}
585 
586 			// Factory is valid - service was found.
587 			if ( xFactory.is() )
588 			{
589 				xFactory->acquire();
590 				pReturn = xFactory.get();
591 			}
592 		}
593 
594 		// Return with result of this operation.
595 		return pReturn ;
596 	}
597 } // extern "C"
598 
599