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_sfx2.hxx"
26 #include "filtergrouping.hxx"
27 #include <sfx2/fcontnr.hxx>
28 #include <sfx2/filedlghelper.hxx>
29 #include <sfx2/sfx.hrc>
30 #include <sfx2/docfac.hxx>
31 #include "sfx2/sfxresid.hxx"
32 #include <osl/thread.h>
33 #include <com/sun/star/ui/dialogs/XFilterGroupManager.hpp>
34 #include <com/sun/star/beans/StringPair.hpp>
35 #include <com/sun/star/uno/Sequence.hxx>
36 #include <unotools/confignode.hxx>
37 #include <comphelper/processfactory.hxx>
38 #include <comphelper/sequenceashashmap.hxx>
39 #include <tools/wldcrd.hxx>
40 #include <tools/diagnose_ex.h>
41 
42 #include <list>
43 #include <vector>
44 #include <map>
45 #include <algorithm>
46 
47 //........................................................................
48 namespace sfx2
49 {
50 //........................................................................
51 
52 //#define DISABLE_GROUPING_AND_CLASSIFYING
53 	// not using the functionallity herein, yet
54 
55 	using namespace ::com::sun::star::uno;
56 	using namespace ::com::sun::star::ui::dialogs;
57 	using namespace ::com::sun::star::lang;
58 	using namespace ::com::sun::star::beans;
59 	using namespace ::utl;
60 
61 	//====================================================================
62 	/**
63 
64 	Some general words about what's going on here ....
65 
66 	<p>In our file open dialog, usually we display every filter we know. That's how it was before: every filter
67 	lead to an own line in the filter list box, e.g. "StarWriter 5.0 Dokument" or "Microsoft Word 97".</p>
68 
69 	<p>But then the PM came. And everything changed ....</p>
70 
71 	<p>A basic idea are groups: Why simply listing all the single filters? Couldn't we draw nice separators
72 	between the filters which logically belong together? I.e. all the filters which open a document in StarWriter:
73 	couldn't we separate them from all the filters which open the document in StarCalc?<br/>
74 	So spoke the PM, and engineering obeyed.</p>
75 
76 	<p>So we have groups. They're just a visual aspect: All the filters of a group are presented together, separated
77 	by a line from other groups.</p>
78 
79 	<p>Let's be honest: How the concrete implementation of the file picker service separates the different groups
80 	is a matter of this implementation. We only do this grouping and suggest it to the FilePicker service ...</p>
81 
82 	<p>Now for the second concept:<br/>
83 	Thinking about it (and that's what the PM did), both "StarWriter 5.0 Dokument" and "Microsoft Word 97"
84 	describe a text document. It's a text. It's of no interest for the user that one of the texts was saved in
85 	MS' format, and one in our own format.<br/>
86 	So in a first step, we want to have a filter entry "Text documents". This would cover both above-mentioned
87 	filters, as well as any other filters for documents which are texts.</p>
88 
89 	<p>Such an entry as "Text documents" is - within the scope of this file - called "class" or "filter class".</p>
90 
91 	<p>In the file-open-dialog, such a class looks like an ordinary filter: it's simply a name in the filter
92 	listbox. Selecting means that all the files matching one of the "sub-filters" are displayed (in the example above,
93 	this would be "*.sdw", "*.doc" and so on).</p>
94 
95 	<p>Now there are two types of filter classes: global ones and local ones. "Text documents" is a global class. As
96 	well as "Spreadsheets". Or "Web pages".<br/>
97 	Let's have a look at a local class: The filters "MS Word 95" and "MS WinWord 6.0" together form the class
98 	"Microsoft Word 6.0 / 95" (don't ask for the reasons. At least not me. Ask the PM). There are a lot of such
99 	local classes ...</p>
100 
101 	<p>The difference between global and local classes is as follows: Global classes are presented in an own group.
102 	There is one dedicated group at the top of the list, containing all the global groups - no local groups and no
103 	single filters.</p>
104 
105 	<p>Ehm - it was a lie. Not really at the top. Before this group, there is this single "All files" entry. It forms
106 	it's own group. But this is uninteresting here.</p>
107 
108 	<p>Local classes must consist of filters which - without the classification - would all belong to the same group.
109 	Then, they're combined to one entry (in the example above: "Microsoft Word 6.0 / 95"), and this entry is inserted
110 	into the file picker filter list, instead of the single filters which form the class.</p>
111 
112 	<p>This is an interesting difference between local and global classes: Filters which are part of a global class
113 	are listed in there own group, too. Filters in local classes aren't listed a second time - neither directly (as
114 	the filter itself) nor indirectly (as part of another local group).</p>
115 
116 	<p>The only exception are filters which are part of a global class <em>and</em> a local class. This is allowed.
117 	Being cotained in two local classes isn't.</p>
118 
119 	<p>So that's all what you need to know: Understand the concept of "filter classes" (a filter class combines
120 	different filters and acts as if it's a filter itself) and the concept of groups (a group just describes a
121 	logical correlation of filters and usually is represented to the user by drawing group separators in the filter
122 	list).</p>
123 
124 	<p>If you got it, go try understanding this file :).</p>
125 
126 	*/
127 
128 
129 	//====================================================================
130 
131 	typedef StringPair							FilterDescriptor;	// a single filter or a filter class (display name and filter mask)
132 	typedef ::std::list< FilterDescriptor > 	FilterGroup;		// a list of single filter entries
133 	typedef ::std::list< FilterGroup >			GroupedFilterList;	// a list of all filters, already grouped
134 
135 	/// the logical name of a filter
136 	typedef ::rtl::OUString 					FilterName;
137 
138 	// a struct which holds references from a logical filter name to a filter group entry
139 	// used for quick lookup of classes (means class entries - entries representing a class)
140 	// which a given filter may belong to
141 	typedef ::std::map< ::rtl::OUString, FilterGroup::iterator >	FilterGroupEntryReferrer;
142 
143 	/// a descriptor for a filter class (which in the final dialog is represented by one filter entry)
144 	typedef struct _tagFilterClass
145 	{
146 		::rtl::OUString 			sDisplayName;		// the display name
147 		Sequence< FilterName >		aSubFilters;		// the (logical) names of the filter which belong to the class
148 	} FilterClass;
149 
150 	typedef ::std::list< FilterClass >									FilterClassList;
151 	typedef ::std::map< ::rtl::OUString, FilterClassList::iterator >	FilterClassReferrer;
152 
153 	typedef ::std::vector< ::rtl::OUString >							StringArray;
154 
155 // =======================================================================
156 // = reading of configuration data
157 // =======================================================================
158 
159 	//--------------------------------------------------------------------
lcl_ReadFilterClass(const OConfigurationNode & _rClassesNode,const::rtl::OUString & _rLogicalClassName,FilterClass & _rClass)160 	void lcl_ReadFilterClass( const OConfigurationNode& _rClassesNode, const ::rtl::OUString& _rLogicalClassName,
161 		FilterClass& /* [out] */ _rClass )
162 	{
163 		static const ::rtl::OUString sDisplaNameNodeName( RTL_CONSTASCII_USTRINGPARAM( "DisplayName" ) );
164 		static const ::rtl::OUString sSubFiltersNodeName( RTL_CONSTASCII_USTRINGPARAM( "Filters" ) );
165 
166 			// the description node for the current class
167 		OConfigurationNode aClassDesc = _rClassesNode.openNode( _rLogicalClassName );
168 
169 		// the values
170 		aClassDesc.getNodeValue( sDisplaNameNodeName ) >>= _rClass.sDisplayName;
171 		aClassDesc.getNodeValue( sSubFiltersNodeName ) >>= _rClass.aSubFilters;
172 	}
173 
174 	//--------------------------------------------------------------------
175 	struct CreateEmptyClassRememberPos : public ::std::unary_function< FilterName, void >
176 	{
177 	protected:
178 		FilterClassList&		m_rClassList;
179 		FilterClassReferrer&	m_rClassesReferrer;
180 
181 	public:
CreateEmptyClassRememberPossfx2::CreateEmptyClassRememberPos182 		CreateEmptyClassRememberPos( FilterClassList& _rClassList, FilterClassReferrer& _rClassesReferrer )
183 			:m_rClassList		( _rClassList )
184 			,m_rClassesReferrer ( _rClassesReferrer )
185 		{
186 		}
187 
188 		// operate on a single class name
operator ()sfx2::CreateEmptyClassRememberPos189 		void operator() ( const FilterName& _rLogicalFilterName )
190 		{
191 			// insert a new (empty) class
192 			m_rClassList.push_back( FilterClass() );
193 			// get the position of this new entry
194 			FilterClassList::iterator aInsertPos = m_rClassList.end();
195 			--aInsertPos;
196 			// remember this position
197 			m_rClassesReferrer.insert( FilterClassReferrer::value_type( _rLogicalFilterName, aInsertPos ) );
198 		}
199 	};
200 
201 	//--------------------------------------------------------------------
202 	struct ReadGlobalFilter : public ::std::unary_function< FilterName, void >
203 	{
204 	protected:
205 		OConfigurationNode		m_aClassesNode;
206 		FilterClassReferrer&	m_aClassReferrer;
207 
208 	public:
ReadGlobalFiltersfx2::ReadGlobalFilter209 		ReadGlobalFilter( const OConfigurationNode& _rClassesNode, FilterClassReferrer& _rClassesReferrer )
210 			:m_aClassesNode 	( _rClassesNode )
211 			,m_aClassReferrer	( _rClassesReferrer )
212 		{
213 		}
214 
215 		// operate on a single logical name
operator ()sfx2::ReadGlobalFilter216 		void operator() ( const FilterName& _rName )
217 		{
218 			FilterClassReferrer::iterator aClassRef = m_aClassReferrer.find( _rName );
219 			if ( m_aClassReferrer.end() == aClassRef )
220 			{
221 				// we do not know this global class
222 				DBG_ERROR( "ReadGlobalFilter::operator(): unknown filter name!" );
223 				// TODO: perhaps we should be more tolerant - at the moment, the filter is dropped
224 				// We could silently push_back it to the container ....
225 			}
226 			else
227 			{
228 				// read the data of this class into the node referred to by aClassRef
229 				lcl_ReadFilterClass( m_aClassesNode, _rName, *aClassRef->second );
230 			}
231 		}
232 	};
233 
234 	//--------------------------------------------------------------------
lcl_ReadGlobalFilters(const OConfigurationNode & _rFilterClassification,FilterClassList & _rGlobalClasses,StringArray & _rGlobalClassNames)235 	void lcl_ReadGlobalFilters( const OConfigurationNode& _rFilterClassification, FilterClassList& _rGlobalClasses, StringArray& _rGlobalClassNames )
236 	{
237 		_rGlobalClasses.clear();
238 		_rGlobalClassNames.clear();
239 
240         //================================================================
241 		// get the list describing the order of all global classes
242 		Sequence< ::rtl::OUString > aGlobalClasses;
243 		_rFilterClassification.getNodeValue( DEFINE_CONST_OUSTRING( "GlobalFilters/Order" ) ) >>= aGlobalClasses;
244 
245 		const ::rtl::OUString* pNames = aGlobalClasses.getConstArray();
246 		const ::rtl::OUString* pNamesEnd = pNames + aGlobalClasses.getLength();
247 
248 		// copy the logical names
249 		_rGlobalClassNames.resize( aGlobalClasses.getLength() );
250 		::std::copy( pNames, pNamesEnd, _rGlobalClassNames.begin() );
251 
252 		// Global classes are presented in an own group, so their order matters (while the order of the
253 		// "local classes" doesn't).
254 		// That's why we can't simply add the global classes to _rGlobalClasses using the order in which they
255 		// are returned from the configuration - it is completely undefined, and we need a _defined_ order.
256 		FilterClassReferrer aClassReferrer;
257 		::std::for_each(
258 			pNames,
259 			pNamesEnd,
260 			CreateEmptyClassRememberPos( _rGlobalClasses, aClassReferrer )
261 		);
262 			// now _rGlobalClasses contains a dummy entry for each global class,
263 			// while aClassReferrer maps from the logical name of the class to the position within _rGlobalClasses where
264 			// it's dummy entry resides
265 
266         //================================================================
267 		// go for all the single class entries
268 		OConfigurationNode aFilterClassesNode =
269 			_rFilterClassification.openNode( DEFINE_CONST_OUSTRING( "GlobalFilters/Classes" ) );
270 		Sequence< ::rtl::OUString > aFilterClasses = aFilterClassesNode.getNodeNames();
271 		::std::for_each(
272 			aFilterClasses.getConstArray(),
273 			aFilterClasses.getConstArray() + aFilterClasses.getLength(),
274 			ReadGlobalFilter( aFilterClassesNode, aClassReferrer )
275 		);
276 	}
277 
278 	//--------------------------------------------------------------------
279 	struct ReadLocalFilter : public ::std::unary_function< FilterName, void >
280 	{
281 	protected:
282 		OConfigurationNode		m_aClassesNode;
283 		FilterClassList&		m_rClasses;
284 
285 	public:
ReadLocalFiltersfx2::ReadLocalFilter286 		ReadLocalFilter( const OConfigurationNode& _rClassesNode, FilterClassList& _rClasses )
287 			:m_aClassesNode ( _rClassesNode )
288 			,m_rClasses 	( _rClasses )
289 		{
290 		}
291 
292 		// operate on a single logical name
operator ()sfx2::ReadLocalFilter293 		void operator() ( const FilterName& _rName )
294 		{
295 			// read the data for this class
296 			FilterClass aClass;
297 			lcl_ReadFilterClass( m_aClassesNode, _rName, aClass );
298 
299 			// insert the class descriptor
300 			m_rClasses.push_back( aClass );
301 		}
302 	};
303 
304 	//--------------------------------------------------------------------
lcl_ReadLocalFilters(const OConfigurationNode & _rFilterClassification,FilterClassList & _rLocalClasses)305 	void lcl_ReadLocalFilters( const OConfigurationNode& _rFilterClassification, FilterClassList& _rLocalClasses )
306 	{
307 		_rLocalClasses.clear();
308 
309 		// the node for the local classes
310 		OConfigurationNode aFilterClassesNode =
311 			_rFilterClassification.openNode( DEFINE_CONST_OUSTRING( "LocalFilters/Classes" ) );
312 		Sequence< ::rtl::OUString > aFilterClasses = aFilterClassesNode.getNodeNames();
313 
314 		::std::for_each(
315 			aFilterClasses.getConstArray(),
316 			aFilterClasses.getConstArray() + aFilterClasses.getLength(),
317 			ReadLocalFilter( aFilterClassesNode, _rLocalClasses )
318 		);
319 	}
320 
321 	//--------------------------------------------------------------------
lcl_ReadClassification(FilterClassList & _rGlobalClasses,StringArray & _rGlobalClassNames,FilterClassList & _rLocalClasses)322 	void lcl_ReadClassification( FilterClassList& _rGlobalClasses, StringArray& _rGlobalClassNames, FilterClassList& _rLocalClasses )
323 	{
324         //================================================================
325 		// open our config node
326 		OConfigurationTreeRoot aFilterClassification = OConfigurationTreeRoot::createWithServiceFactory(
327 			::comphelper::getProcessServiceFactory(),
328 			DEFINE_CONST_OUSTRING( "org.openoffice.Office.UI/FilterClassification" ),
329 			-1,
330 			OConfigurationTreeRoot::CM_READONLY
331 		);
332 
333         //================================================================
334 		// go for the global classes
335 		lcl_ReadGlobalFilters( aFilterClassification, _rGlobalClasses, _rGlobalClassNames );
336 
337         //================================================================
338 		// fo for the local classes
339 		lcl_ReadLocalFilters( aFilterClassification, _rLocalClasses );
340 
341 	}
342 
343 // =======================================================================
344 // = grouping and classifying
345 // =======================================================================
346 
347 	//--------------------------------------------------------------------
348 	// a struct which adds helps remembering a reference to a class entry
349 	struct ReferToFilterEntry : public ::std::unary_function< FilterName, void >
350 	{
351 	protected:
352 		FilterGroupEntryReferrer&	m_rEntryReferrer;
353 		FilterGroup::iterator		m_aClassPos;
354 
355 	public:
ReferToFilterEntrysfx2::ReferToFilterEntry356 		ReferToFilterEntry( FilterGroupEntryReferrer& _rEntryReferrer, const FilterGroup::iterator& _rClassPos )
357 			:m_rEntryReferrer( _rEntryReferrer )
358 			,m_aClassPos( _rClassPos )
359 		{
360 		}
361 
362 		// operate on a single filter name
operator ()sfx2::ReferToFilterEntry363 		void operator() ( const FilterName& _rName )
364 		{
365 #ifdef DBG_UTIL
366 			::std::pair< FilterGroupEntryReferrer::iterator, bool > aInsertRes =
367 #endif
368 			m_rEntryReferrer.insert( FilterGroupEntryReferrer::value_type( _rName, m_aClassPos ) );
369 			DBG_ASSERT( aInsertRes.second, "ReferToFilterEntry::operator(): already have an element for this name!" );
370 		}
371 	};
372 
373 	//--------------------------------------------------------------------
374 	struct FillClassGroup : public ::std::unary_function< FilterClass, void >
375 	{
376 	protected:
377 		FilterGroup&				m_rClassGroup;
378 		FilterGroupEntryReferrer&	m_rClassReferrer;
379 
380 	public:
FillClassGroupsfx2::FillClassGroup381 		FillClassGroup( FilterGroup& _rClassGroup, FilterGroupEntryReferrer& _rClassReferrer )
382 			:m_rClassGroup		( _rClassGroup )
383 			,m_rClassReferrer	( _rClassReferrer )
384 		{
385 		}
386 
387 		// operate on a single class
operator ()sfx2::FillClassGroup388 		void operator() ( const FilterClass& _rClass )
389 		{
390 			// create an empty filter descriptor for the class
391 			FilterDescriptor aClassEntry;
392 			// set it's name (which is all we know by now)
393 			aClassEntry.First = _rClass.sDisplayName;
394 
395 			// add it to the group
396 			m_rClassGroup.push_back( aClassEntry );
397 			// the position of the newly added class
398 			FilterGroup::iterator aClassEntryPos = m_rClassGroup.end();
399 			--aClassEntryPos;
400 
401 			// and for all the sub filters of the class, remember the class
402 			// (respectively the position of the class it the group)
403 			::std::for_each(
404 				_rClass.aSubFilters.getConstArray(),
405 				_rClass.aSubFilters.getConstArray() + _rClass.aSubFilters.getLength(),
406 				ReferToFilterEntry( m_rClassReferrer, aClassEntryPos )
407 			);
408 		}
409 	};
410 
411 	//--------------------------------------------------------------------
412 	static const sal_Unicode s_cWildcardSeparator( ';' );
413 
414     //====================================================================
getSeparatorString()415 	const ::rtl::OUString& getSeparatorString()
416 	{
417 		static ::rtl::OUString s_sSeparatorString( &s_cWildcardSeparator, 1 );
418 		return s_sSeparatorString;
419 	}
420 
421     //====================================================================
422 	struct CheckAppendSingleWildcard : public ::std::unary_function< ::rtl::OUString, void >
423 	{
424 		::rtl::OUString& _rToBeExtended;
425 
CheckAppendSingleWildcardsfx2::CheckAppendSingleWildcard426 		CheckAppendSingleWildcard( ::rtl::OUString& _rBase ) : _rToBeExtended( _rBase ) { }
427 
operator ()sfx2::CheckAppendSingleWildcard428 		void operator() ( const ::rtl::OUString& _rWC )
429 		{
430 			// check for double wildcards
431 			sal_Int32 nExistentPos = _rToBeExtended.indexOf( _rWC );
432 			if	( -1 < nExistentPos )
433 			{	// found this wildcard (already part of _rToBeExtended)
434 				const sal_Unicode* pBuffer = _rToBeExtended.getStr();
435 				if	(	( 0 == nExistentPos )
436 					||	( s_cWildcardSeparator == pBuffer[ nExistentPos - 1 ] )
437 					)
438 				{	// the wildcard really starts at this position (it starts at pos 0 or the previous character is a separator
439 					sal_Int32 nExistentWCEnd = nExistentPos + _rWC.getLength();
440 					if	(	( _rToBeExtended.getLength() == nExistentWCEnd )
441 						||	( s_cWildcardSeparator == pBuffer[ nExistentWCEnd ] )
442 						)
443 					{	// it's really the complete wildcard we found
444 						// (not something like _rWC being "*.t" and _rToBeExtended containing "*.txt")
445 						// -> outta here
446 						return;
447 					}
448 				}
449 			}
450 
451 			if ( _rToBeExtended.getLength() )
452 				_rToBeExtended += getSeparatorString();
453 			_rToBeExtended += _rWC;
454 		}
455 	};
456 
457     //====================================================================
458 	// a helper struct which adds a fixed (Sfx-)filter to a filter group entry given by iterator
459 	struct AppendWildcardToDescriptor : public ::std::unary_function< FilterGroupEntryReferrer::value_type, void >
460 	{
461 	protected:
462 		::std::vector< ::rtl::OUString > aWildCards;
463 
464 	public:
465 		AppendWildcardToDescriptor( const String& _rWildCard );
466 
467 		// operate on a single class entry
operator ()sfx2::AppendWildcardToDescriptor468 		void operator() ( const FilterGroupEntryReferrer::value_type& _rClassReference )
469 		{
470 			// simply add our wildcards
471 			::std::for_each(
472 				aWildCards.begin(),
473 				aWildCards.end(),
474 				CheckAppendSingleWildcard( _rClassReference.second->Second )
475 			);
476 		}
477 	};
478 
479     //====================================================================
AppendWildcardToDescriptor(const String & _rWildCard)480 	AppendWildcardToDescriptor::AppendWildcardToDescriptor( const String& _rWildCard )
481 	{
482 		DBG_ASSERT( _rWildCard.Len(),
483 			"AppendWildcardToDescriptor::AppendWildcardToDescriptor: invalid wildcard!" );
484 		DBG_ASSERT( _rWildCard.GetBuffer()[0] != s_cWildcardSeparator,
485 			"AppendWildcardToDescriptor::AppendWildcardToDescriptor: wildcard already separated!" );
486 
487 		aWildCards.reserve( _rWildCard.GetTokenCount( s_cWildcardSeparator ) );
488 
489 		const sal_Unicode* pTokenLoop = _rWildCard.GetBuffer();
490 		const sal_Unicode* pTokenLoopEnd = pTokenLoop + _rWildCard.Len();
491 		const sal_Unicode* pTokenStart = pTokenLoop;
492 		for ( ; pTokenLoop != pTokenLoopEnd; ++pTokenLoop )
493 		{
494 			if ( ( s_cWildcardSeparator == *pTokenLoop ) && ( pTokenLoop > pTokenStart ) )
495 			{	// found a new token separator (and a non-empty token)
496 				aWildCards.push_back( ::rtl::OUString( pTokenStart, pTokenLoop - pTokenStart ) );
497 
498 				// search the start of the next token
499 				while ( ( pTokenStart != pTokenLoopEnd ) && ( *pTokenStart != s_cWildcardSeparator ) )
500 					++pTokenStart;
501 
502 				if ( pTokenStart == pTokenLoopEnd )
503 					// reached the end
504 					break;
505 
506 				++pTokenStart;
507 				pTokenLoop = pTokenStart;
508 			}
509 		}
510 		if ( pTokenLoop > pTokenStart )
511 			// the last one ....
512 			aWildCards.push_back( ::rtl::OUString( pTokenStart, pTokenLoop - pTokenStart ) );
513 	}
514 
515 	//--------------------------------------------------------------------
lcl_InitGlobalClasses(GroupedFilterList & _rAllFilters,const FilterClassList & _rGlobalClasses,FilterGroupEntryReferrer & _rGlobalClassesRef)516 	void lcl_InitGlobalClasses( GroupedFilterList& _rAllFilters, const FilterClassList& _rGlobalClasses, FilterGroupEntryReferrer& _rGlobalClassesRef )
517 	{
518 		// we need an extra group in our "all filters" container
519 		_rAllFilters.push_front( FilterGroup() );
520 		FilterGroup& rGlobalFilters = _rAllFilters.front();
521 			// it's important to work on the reference: we want to access the members of this filter group
522 			// by an iterator (FilterGroup::const_iterator)
523 		// the referrer for the global classes
524 
525 		// initialize the group
526 		::std::for_each(
527 			_rGlobalClasses.begin(),
528 			_rGlobalClasses.end(),
529 			FillClassGroup( rGlobalFilters, _rGlobalClassesRef )
530 		);
531 			// now we have:
532 			// in rGlobalFilters: a list of FilterDescriptor's, where each's discriptor's display name is set to the name of a class
533 			// in aGlobalClassesRef: a mapping from logical filter names to positions within rGlobalFilters
534 			//	this way, if we encounter an arbitrary filter, we can easily (and efficient) check if it belongs to a global class
535 			//	and modify the descriptor for this class accordingly
536 	}
537 
538 	//--------------------------------------------------------------------
539 	typedef ::std::vector< ::std::pair< FilterGroupEntryReferrer::mapped_type, FilterGroup::iterator > >
540 			MapGroupEntry2GroupEntry;
541 			// this is not really a map - it's just called this way because it is used as a map
542 
543 	struct FindGroupEntry : public ::std::unary_function< MapGroupEntry2GroupEntry::value_type, sal_Bool >
544 	{
545 		FilterGroupEntryReferrer::mapped_type aLookingFor;
FindGroupEntrysfx2::FindGroupEntry546 		FindGroupEntry( FilterGroupEntryReferrer::mapped_type _rLookingFor ) : aLookingFor( _rLookingFor ) { }
547 
operator ()sfx2::FindGroupEntry548 		sal_Bool operator() ( const MapGroupEntry2GroupEntry::value_type& _rMapEntry )
549 		{
550 			return _rMapEntry.first == aLookingFor ? sal_True : sal_False;
551 		}
552 	};
553 
554 	struct CopyGroupEntryContent : public ::std::unary_function< MapGroupEntry2GroupEntry::value_type, void >
555 	{
operator ()sfx2::CopyGroupEntryContent556 		void operator() ( const MapGroupEntry2GroupEntry::value_type& _rMapEntry )
557 		{
558 #ifdef DBG_UTIL
559 			FilterDescriptor aHaveALook = *_rMapEntry.first;
560 #endif
561 			*_rMapEntry.second = *_rMapEntry.first;
562 		}
563 	};
564 
565 	//--------------------------------------------------------------------
566 	struct CopyNonEmptyFilter : public ::std::unary_function< FilterDescriptor, void >
567 	{
568 		FilterGroup& rTarget;
CopyNonEmptyFiltersfx2::CopyNonEmptyFilter569 		CopyNonEmptyFilter( FilterGroup& _rTarget ) :rTarget( _rTarget ) { }
570 
operator ()sfx2::CopyNonEmptyFilter571 		void operator() ( const FilterDescriptor& _rFilter )
572 		{
573 			if ( _rFilter.Second.getLength() )
574 				rTarget.push_back( _rFilter );
575 		}
576 	};
577 
578 	//--------------------------------------------------------------------
lcl_GroupAndClassify(TSortedFilterList & _rFilterMatcher,GroupedFilterList & _rAllFilters)579 	void lcl_GroupAndClassify( TSortedFilterList& _rFilterMatcher, GroupedFilterList& _rAllFilters )
580 	{
581 		_rAllFilters.clear();
582 
583         // ===============================================================
584 		// read the classification of filters
585 		FilterClassList aGlobalClasses, aLocalClasses;
586 		StringArray aGlobalClassNames;
587 		lcl_ReadClassification( aGlobalClasses, aGlobalClassNames, aLocalClasses );
588 
589         // ===============================================================
590 		// for the global filter classes
591 		FilterGroupEntryReferrer aGlobalClassesRef;
592 		lcl_InitGlobalClasses( _rAllFilters, aGlobalClasses, aGlobalClassesRef );
593 
594 		// insert as much placeholders (FilterGroup's) into _rAllFilter for groups as we have global classes
595 		// (this assumes that both numbers are the same, which, speaking strictly, must not hold - but it does, as we know ...)
596 		sal_Int32 nGlobalClasses = aGlobalClasses.size();
597 		while ( nGlobalClasses-- )
598 			_rAllFilters.push_back( FilterGroup() );
599 
600         // ===============================================================
601 		// for the local classes:
602 		// if n filters belong to a local class, they do not appear in their respective group explicitly, instead
603 		// and entry for the class is added to the group and the extensions of the filters are collected under
604 		// this entry
605 		FilterGroupEntryReferrer aLocalClassesRef;
606 		FilterGroup aCollectedLocals;
607 		::std::for_each(
608 			aLocalClasses.begin(),
609 			aLocalClasses.end(),
610 			FillClassGroup( aCollectedLocals, aLocalClassesRef )
611 		);
612 		// to map from the position within aCollectedLocals to positions within the real groups
613 		// (where they finally belong to)
614 		MapGroupEntry2GroupEntry	aLocalFinalPositions;
615 
616         // ===============================================================
617 		// now add the filters
618 		// the group which we currently work with
619 		GroupedFilterList::iterator aCurrentGroup = _rAllFilters.end(); // no current group
620 		// the filter container of the current group - if this changes between two filters, a new group is reached
621 		String aCurrentServiceName;
622 
623 		String sFilterWildcard;
624 		::rtl::OUString sFilterName;
625 		// loop through all the filters
626 		for ( const SfxFilter* pFilter = _rFilterMatcher.First(); pFilter; pFilter = _rFilterMatcher.Next() )
627 		{
628             sFilterName = pFilter->GetFilterName();
629 			sFilterWildcard = pFilter->GetWildcard().GetWildCard();
630 			AppendWildcardToDescriptor aExtendWildcard( sFilterWildcard );
631 
632 			DBG_ASSERT( sFilterWildcard.Len(), "sfx2::lcl_GroupAndClassify: invalid wildcard of this filter!" );
633 
634             // ===========================================================
635 			// check for a change in the group
636 			String aServiceName = pFilter->GetServiceName();
637 			if ( aServiceName != aCurrentServiceName )
638 			{	// we reached a new group
639 
640 				::rtl::OUString sDocServName = aServiceName;
641 
642 				// look for the place in _rAllFilters where this ne group belongs - this is determined
643 				// by the order of classes in aGlobalClassNames
644 				GroupedFilterList::iterator aGroupPos = _rAllFilters.begin();
645 				DBG_ASSERT( aGroupPos != _rAllFilters.end(),
646 					"sfx2::lcl_GroupAndClassify: invalid all-filters array here!" );
647 					// the loop below will work on invalid objects else ...
648 				++aGroupPos;
649 				StringArray::iterator aGlobalIter = aGlobalClassNames.begin();
650 				while	(	( aGroupPos != _rAllFilters.end() )
651 						&&  ( aGlobalIter != aGlobalClassNames.end() )
652 						&&	( *aGlobalIter != sDocServName )
653 						)
654 				{
655 					++aGlobalIter;
656 					++aGroupPos;
657 				}
658 				if ( aGroupPos != _rAllFilters.end() )
659 					// we found a global class name which matchies the doc service name -> fill the filters of this
660 					// group in the respective prepared group
661 					aCurrentGroup = aGroupPos;
662 				else
663 					// insert a new entry in our overall-list
664 					aCurrentGroup = _rAllFilters.insert( _rAllFilters.end(), FilterGroup() );
665 
666 				// remember the container to properly detect the next group
667 				aCurrentServiceName = aServiceName;
668 			}
669 
670 			DBG_ASSERT( aCurrentGroup != _rAllFilters.end(), "sfx2::lcl_GroupAndClassify: invalid current group!" );
671 
672             // ===========================================================
673 			// check if the filter is part of a global group
674 			::std::pair< FilterGroupEntryReferrer::iterator, FilterGroupEntryReferrer::iterator >
675 				aBelongsTo = aGlobalClassesRef.equal_range( sFilterName );
676 			// add the filter to the entries for these classes
677 			// (if they exist - if not, the range is empty and the for_each is a no-op)
678 			::std::for_each(
679 				aBelongsTo.first,
680 				aBelongsTo.second,
681 				aExtendWildcard
682 			);
683 
684             // ===========================================================
685 			// add the filter to it's group
686 
687 			// for this, check if the filter is part of a local filter
688 			FilterGroupEntryReferrer::iterator aBelongsToLocal = aLocalClassesRef.find( sFilterName );
689 			if ( aLocalClassesRef.end() != aBelongsToLocal )
690 			{
691 /*
692 #ifdef DBG_UTIL
693 				const ::rtl::OUString& rLocalClassDisplayName = aBelongsToLocal->second->First;
694 				const ::rtl::OUString& rLocalClassExtension = aBelongsToLocal->second->Second;
695 #endif
696 */
697 				// okay, there is a local class which the filter belongs to
698 				// -> append the wildcard
699 				aExtendWildcard( *aBelongsToLocal );
700 
701 				MapGroupEntry2GroupEntry::iterator aThisGroupFinalPos =
702 					::std::find_if( aLocalFinalPositions.begin(), aLocalFinalPositions.end(), FindGroupEntry( aBelongsToLocal->second ) );
703 
704 				if ( aLocalFinalPositions.end() == aThisGroupFinalPos )
705 				{	// the position within aCollectedLocals has not been mapped to a final position
706 					// within the "real" group (aCollectedLocals is only temporary)
707 					// -> do this now (as we just encountered the first filter belonging to this local class
708 					// add a new entry which is the "real" group entry
709 					aCurrentGroup->push_back( FilterDescriptor( aBelongsToLocal->second->First, String() ) );
710 					// the position where we inserted the entry
711 					FilterGroup::iterator aInsertPos = aCurrentGroup->end();
712 					--aInsertPos;
713 					// remember this pos
714 					aLocalFinalPositions.push_back( MapGroupEntry2GroupEntry::value_type( aBelongsToLocal->second, aInsertPos ) );
715 				}
716 			}
717 			else
718 				aCurrentGroup->push_back( FilterDescriptor( pFilter->GetUIName(), sFilterWildcard ) );
719 		}
720 
721 		// now just complete the infos for the local groups:
722 		// During the above loop, they have been collected in aCollectedLocals, but this is only temporary
723 		// They have to be copied into their final positions (which are stored in aLocalFinalPositions)
724 		::std::for_each(
725 			aLocalFinalPositions.begin(),
726 			aLocalFinalPositions.end(),
727 			CopyGroupEntryContent()
728 		);
729 
730 		// and remove local groups which do not apply - e.g. have no entries due to the limited content of the
731 		// current SfxFilterMatcherIter
732 
733 		FilterGroup& rGlobalFilters = _rAllFilters.front();
734 		FilterGroup aNonEmptyGlobalFilters;
735 		::std::for_each(
736 			rGlobalFilters.begin(),
737 			rGlobalFilters.end(),
738 			CopyNonEmptyFilter( aNonEmptyGlobalFilters )
739 		);
740 		rGlobalFilters.swap( aNonEmptyGlobalFilters );
741 	}
742 
743 	//--------------------------------------------------------------------
744 	struct AppendFilter : public ::std::unary_function< FilterDescriptor, void >
745 	{
746 		protected:
747 			Reference< XFilterManager > 		m_xFilterManager;
748 			FileDialogHelper_Impl*				m_pFileDlgImpl;
749 			bool								m_bAddExtension;
750 
751 		public:
AppendFiltersfx2::AppendFilter752 			AppendFilter( const Reference< XFilterManager >& _rxFilterManager,
753 						  FileDialogHelper_Impl* _pImpl, bool _bAddExtension ) :
754 
755 				m_xFilterManager( _rxFilterManager ),
756 				m_pFileDlgImpl	( _pImpl ),
757 				m_bAddExtension	( _bAddExtension )
758 
759 			{
760 				DBG_ASSERT( m_xFilterManager.is(), "AppendFilter::AppendFilter: invalid filter manager!" );
761 				DBG_ASSERT( m_pFileDlgImpl, "AppendFilter::AppendFilter: invalid filedlg impl!" );
762 			}
763 
764 			// operate on a single filter
operator ()sfx2::AppendFilter765 			void operator() ( const FilterDescriptor& _rFilterEntry )
766 			{
767 				String sDisplayText = m_bAddExtension
768 					? addExtension( _rFilterEntry.First, _rFilterEntry.Second, sal_True, *m_pFileDlgImpl )
769 					: _rFilterEntry.First;
770 				m_xFilterManager->appendFilter( sDisplayText, _rFilterEntry.Second );
771 			}
772 	};
773 
774 // =======================================================================
775 // = handling for the "all files" entry
776 // =======================================================================
777 
778 	//--------------------------------------------------------------------
lcl_hasAllFilesFilter(TSortedFilterList & _rFilterMatcher,String & _rAllFilterName)779 	sal_Bool lcl_hasAllFilesFilter( TSortedFilterList& _rFilterMatcher, String& /* [out] */ _rAllFilterName )
780 	{
781 		::rtl::OUString sUIName;
782 		sal_Bool		bHasAll = sal_False;
783 		_rAllFilterName = String( SfxResId( STR_SFX_FILTERNAME_ALL ) );
784 
785         // ===============================================================
786 		// check if there's already a filter <ALL>
787 		for ( const SfxFilter* pFilter = _rFilterMatcher.First(); pFilter && !bHasAll; pFilter = _rFilterMatcher.Next() )
788 		{
789 			if ( pFilter->GetUIName() == _rAllFilterName )
790 				bHasAll = sal_True;
791 		}
792 		return bHasAll;
793 	}
794 
795 	//--------------------------------------------------------------------
lcl_EnsureAllFilesEntry(TSortedFilterList & _rFilterMatcher,GroupedFilterList & _rFilters)796 	void lcl_EnsureAllFilesEntry( TSortedFilterList& _rFilterMatcher, GroupedFilterList& _rFilters )
797 	{
798         // ===============================================================
799 		String sAllFilterName;
800 		if ( !lcl_hasAllFilesFilter( _rFilterMatcher, sAllFilterName ) )
801 		{
802 			// get the first group of filters (by definition, this group contains the global classes)
803 			DBG_ASSERT( !_rFilters.empty(), "lcl_EnsureAllFilesEntry: invalid filter list!" );
804 			if ( !_rFilters.empty() )
805 			{
806 				FilterGroup& rGlobalClasses = *_rFilters.begin();
807 				rGlobalClasses.push_front( FilterDescriptor( sAllFilterName, DEFINE_CONST_UNICODE( FILEDIALOG_FILTER_ALL ) ) );
808 			}
809 		}
810 	}
811 
812 #ifdef DISABLE_GROUPING_AND_CLASSIFYING
813 	//--------------------------------------------------------------------
lcl_EnsureAllFilesEntry(TSortedFilterList & _rFilterMatcher,const Reference<XFilterManager> & _rxFilterManager,::rtl::OUString & _rFirstNonEmpty)814 	void lcl_EnsureAllFilesEntry( TSortedFilterList& _rFilterMatcher, const Reference< XFilterManager >& _rxFilterManager, ::rtl::OUString& _rFirstNonEmpty )
815 	{
816         // ===============================================================
817 		String sAllFilterName;
818 		if ( !lcl_hasAllFilesFilter( _rFilterMatcher, sAllFilterName ) )
819 		{
820 			try
821 			{
822 				_rxFilterManager->appendFilter( sAllFilterName, DEFINE_CONST_UNICODE( FILEDIALOG_FILTER_ALL ) );
823 				_rFirstNonEmpty = sAllFilterName;
824 			}
825 			catch( const IllegalArgumentException& )
826 			{
827 #ifdef DBG_UTIL
828 				ByteString aMsg( "sfx2::lcl_EnsureAllFilesEntry: could not append Filter" );
829 				aMsg += ByteString( String( sAllFilterName ), RTL_TEXTENCODING_UTF8 );
830 				DBG_ERROR( aMsg.GetBuffer() );
831 #endif
832 			}
833 		}
834 
835 	}
836 #endif
837 
838 // =======================================================================
839 // = filling an XFilterManager
840 // =======================================================================
841 
842 	//--------------------------------------------------------------------
843 	struct AppendFilterGroup : public ::std::unary_function< FilterGroup, void >
844 	{
845 	protected:
846 		Reference< XFilterManager > 		m_xFilterManager;
847 		Reference< XFilterGroupManager >	m_xFilterGroupManager;
848 		FileDialogHelper_Impl*				m_pFileDlgImpl;
849 
850 	public:
AppendFilterGroupsfx2::AppendFilterGroup851 		AppendFilterGroup( const Reference< XFilterManager >& _rxFilterManager, FileDialogHelper_Impl* _pImpl )
852 			:m_xFilterManager		( _rxFilterManager )
853 			,m_xFilterGroupManager	( _rxFilterManager, UNO_QUERY )
854 			,m_pFileDlgImpl			( _pImpl )
855 		{
856 			DBG_ASSERT( m_xFilterManager.is(), "AppendFilterGroup::AppendFilterGroup: invalid filter manager!" );
857 			DBG_ASSERT( m_pFileDlgImpl, "AppendFilterGroup::AppendFilterGroup: invalid filedlg impl!" );
858 		}
859 
appendGroupsfx2::AppendFilterGroup860 		void appendGroup( const FilterGroup& _rGroup, bool _bAddExtension )
861 		{
862 			try
863 			{
864 				if ( m_xFilterGroupManager.is() )
865 				{	// the file dialog implementation supports visual grouping of filters
866 					// create a representation of the group which is understandable by the XFilterGroupManager
867 					if ( _rGroup.size() )
868 					{
869 						Sequence< StringPair > aFilters( _rGroup.size() );
870 						::std::copy(
871 							_rGroup.begin(),
872 							_rGroup.end(),
873 							aFilters.getArray()
874 						);
875 						if ( _bAddExtension )
876 						{
877 							StringPair* pFilters = aFilters.getArray();
878 							StringPair* pEnd = pFilters + aFilters.getLength();
879 							for ( ; pFilters != pEnd; ++pFilters )
880 								pFilters->First = addExtension( pFilters->First, pFilters->Second, sal_True, *m_pFileDlgImpl );
881 						}
882 						m_xFilterGroupManager->appendFilterGroup( ::rtl::OUString(), aFilters );
883 					}
884 				}
885 				else
886 				{
887 					::std::for_each(
888 						_rGroup.begin(),
889 						_rGroup.end(),
890 						AppendFilter( m_xFilterManager, m_pFileDlgImpl, _bAddExtension ) );
891 				}
892 			}
893 			catch( const Exception& )
894 			{
895                 DBG_UNHANDLED_EXCEPTION();
896 			}
897 		}
898 
899 		// operate on a single filter group
operator ()sfx2::AppendFilterGroup900 		void operator() ( const FilterGroup& _rGroup )
901 		{
902 			appendGroup( _rGroup, true );
903 		}
904 	};
905 
906 	//--------------------------------------------------------------------
TSortedFilterList(const::com::sun::star::uno::Reference<::com::sun::star::container::XEnumeration> & xFilterList)907     TSortedFilterList::TSortedFilterList(const ::com::sun::star::uno::Reference< ::com::sun::star::container::XEnumeration >& xFilterList)
908         : m_nIterator(0)
909     {
910         if (!xFilterList.is())
911             return;
912 
913         m_lFilters.clear();
914         while(xFilterList->hasMoreElements())
915         {
916             ::comphelper::SequenceAsHashMap lFilterProps (xFilterList->nextElement());
917             ::rtl::OUString                 sFilterName  = lFilterProps.getUnpackedValueOrDefault(
918                                                              ::rtl::OUString::createFromAscii("Name"),
919                                                              ::rtl::OUString());
920             if (sFilterName.getLength())
921                 m_lFilters.push_back(sFilterName);
922         }
923     }
924 
925 	//--------------------------------------------------------------------
First()926     const SfxFilter* TSortedFilterList::First()
927     {
928         m_nIterator = 0;
929         return impl_getFilter(m_nIterator);
930     }
931 
932 	//--------------------------------------------------------------------
Next()933     const SfxFilter* TSortedFilterList::Next()
934     {
935         ++m_nIterator;
936         return impl_getFilter(m_nIterator);
937     }
938 
939 	//--------------------------------------------------------------------
impl_getFilter(sal_Int32 nIndex)940     const SfxFilter* TSortedFilterList::impl_getFilter(sal_Int32 nIndex)
941     {
942         if (nIndex<0 || nIndex>=(sal_Int32)m_lFilters.size())
943             return 0;
944         const ::rtl::OUString& sFilterName = m_lFilters[nIndex];
945         if (!sFilterName.getLength())
946             return 0;
947         return SfxFilter::GetFilterByName(String(sFilterName));
948     }
949 
950 	//--------------------------------------------------------------------
appendFiltersForSave(TSortedFilterList & _rFilterMatcher,const Reference<XFilterManager> & _rxFilterManager,::rtl::OUString & _rFirstNonEmpty,FileDialogHelper_Impl & _rFileDlgImpl,const::rtl::OUString & _rFactory)951 	void appendFiltersForSave( TSortedFilterList& _rFilterMatcher,
952 							   const Reference< XFilterManager >& _rxFilterManager,
953 							   ::rtl::OUString& _rFirstNonEmpty, FileDialogHelper_Impl& _rFileDlgImpl,
954                                const ::rtl::OUString& _rFactory )
955 	{
956 		DBG_ASSERT( _rxFilterManager.is(), "sfx2::appendFiltersForSave: invalid manager!" );
957 		if ( !_rxFilterManager.is() )
958 			return;
959 
960 		::rtl::OUString sUIName;
961         ::rtl::OUString sExtension;
962 
963         // retrieve the default filter for this application module.
964         // It must be set as first of the generated filter list.
965         const SfxFilter* pDefaultFilter = SfxFilterContainer::GetDefaultFilter_Impl(_rFactory);
966         // --> PB 2004-11-01 #i32434# only use one extension
967         // (and always the first if there are more than one)
968         sExtension = pDefaultFilter->GetWildcard().GetWildCard().GetToken( 0, ';' );
969         // <--
970         sUIName = addExtension( pDefaultFilter->GetUIName(), sExtension, sal_False, _rFileDlgImpl );
971         try
972         {
973             _rxFilterManager->appendFilter( sUIName, sExtension );
974             if ( !_rFirstNonEmpty.getLength() )
975                 _rFirstNonEmpty = sUIName;
976         }
977         catch( IllegalArgumentException )
978         {
979 #ifdef DBG_UTIL
980             ByteString aMsg( "Could not append DefaultFilter" );
981             aMsg += ByteString( String( sUIName ), osl_getThreadTextEncoding() );
982             DBG_ERRORFILE( aMsg.GetBuffer() );
983 #endif
984         }
985 
986 		for ( const SfxFilter* pFilter = _rFilterMatcher.First(); pFilter; pFilter = _rFilterMatcher.Next() )
987 		{
988             if (pFilter->GetName() == pDefaultFilter->GetName())
989                 continue;
990 
991             // --> PB 2004-09-21 #i32434# only use one extension
992             // (and always the first if there are more than one)
993             sExtension = pFilter->GetWildcard().GetWildCard().GetToken( 0, ';' );
994             // <--
995 			sUIName = addExtension( pFilter->GetUIName(), sExtension, sal_False, _rFileDlgImpl );
996 			try
997 			{
998 				_rxFilterManager->appendFilter( sUIName, sExtension );
999 				if ( !_rFirstNonEmpty.getLength() )
1000 					_rFirstNonEmpty = sUIName;
1001 			}
1002 			catch( IllegalArgumentException )
1003 			{
1004 	#ifdef DBG_UTIL
1005 				ByteString aMsg( "Could not append Filter" );
1006 				aMsg += ByteString( String( sUIName ), osl_getThreadTextEncoding() );
1007 				DBG_ERRORFILE( aMsg.GetBuffer() );
1008 	#endif
1009 			}
1010 		}
1011 	}
1012 
1013 	struct ExportFilter
1014 	{
ExportFiltersfx2::ExportFilter1015 		ExportFilter( const rtl::OUString& _aUIName, const rtl::OUString& _aWildcard ) :
1016 			aUIName( _aUIName ), aWildcard( _aWildcard ) {}
1017 
1018 		rtl::OUString aUIName;
1019 		rtl::OUString aWildcard;
1020 	};
1021 
1022 	//--------------------------------------------------------------------
appendExportFilters(TSortedFilterList & _rFilterMatcher,const Reference<XFilterManager> & _rxFilterManager,::rtl::OUString & _rFirstNonEmpty,FileDialogHelper_Impl & _rFileDlgImpl)1023 	void appendExportFilters( TSortedFilterList& _rFilterMatcher,
1024 							  const Reference< XFilterManager >& _rxFilterManager,
1025 							  ::rtl::OUString& _rFirstNonEmpty, FileDialogHelper_Impl& _rFileDlgImpl )
1026 	{
1027 		DBG_ASSERT( _rxFilterManager.is(), "sfx2::appendExportFilters: invalid manager!" );
1028 		if ( !_rxFilterManager.is() )
1029 			return;
1030 
1031         sal_Int32                           nHTMLIndex  = -1;
1032         sal_Int32                           nXHTMLIndex  = -1;
1033         sal_Int32                           nPDFIndex   = -1;
1034 		sal_Int32							nFlashIndex = -1;
1035 		::rtl::OUString						sUIName;
1036 		::rtl::OUString						sExtensions;
1037 		std::vector< ExportFilter >			aImportantFilterGroup;
1038 		std::vector< ExportFilter >			aFilterGroup;
1039 		Reference< XFilterGroupManager >	xFilterGroupManager( _rxFilterManager, UNO_QUERY );
1040         ::rtl::OUString                     sTypeName;
1041         const ::rtl::OUString               sWriterHTMLType( DEFINE_CONST_OUSTRING("writer_web_HTML") );
1042         const ::rtl::OUString               sGraphicHTMLType( DEFINE_CONST_OUSTRING("graphic_HTML") );
1043         const ::rtl::OUString               sXHTMLType( DEFINE_CONST_OUSTRING("XHTML_File") );
1044         const ::rtl::OUString               sPDFType( DEFINE_CONST_OUSTRING("pdf_Portable_Document_Format") );
1045         const ::rtl::OUString               sFlashType( DEFINE_CONST_OUSTRING("graphic_SWF") );
1046 
1047 		for ( const SfxFilter* pFilter = _rFilterMatcher.First(); pFilter; pFilter = _rFilterMatcher.Next() )
1048 		{
1049             sTypeName   = pFilter->GetTypeName();
1050 			sUIName		= pFilter->GetUIName();
1051 			sExtensions = pFilter->GetWildcard().GetWildCard();
1052 			ExportFilter aExportFilter( sUIName, sExtensions );
1053 			String aExt = sExtensions;
1054 
1055             if ( nHTMLIndex == -1 &&
1056                 ( sTypeName.equals( sWriterHTMLType ) || sTypeName.equals( sGraphicHTMLType ) ) )
1057             {
1058                 aImportantFilterGroup.insert( aImportantFilterGroup.begin(), aExportFilter );
1059                 nHTMLIndex = 0;
1060             }
1061             else if ( nXHTMLIndex == -1 && sTypeName.equals( sXHTMLType ) )
1062             {
1063                 std::vector< ExportFilter >::iterator aIter = aImportantFilterGroup.begin();
1064                 if ( nHTMLIndex == -1 )
1065                     aImportantFilterGroup.insert( aIter, aExportFilter );
1066                 else
1067                     aImportantFilterGroup.insert( ++aIter, aExportFilter );
1068                 nXHTMLIndex = 0;
1069             }
1070             else if ( nPDFIndex == -1 && sTypeName.equals( sPDFType ) )
1071 			{
1072                 std::vector< ExportFilter >::iterator aIter = aImportantFilterGroup.begin();
1073                 if ( nHTMLIndex != -1 )
1074                     aIter++;
1075                 if ( nXHTMLIndex != -1 )
1076                     aIter++;
1077                 aImportantFilterGroup.insert( aIter, aExportFilter );
1078 				nPDFIndex = 0;
1079 			}
1080             else if ( nFlashIndex == -1 && sTypeName.equals( sFlashType ) )
1081 			{
1082 				std::vector< ExportFilter >::iterator aIter = aImportantFilterGroup.begin();
1083                 if ( nHTMLIndex != -1 )
1084                     aIter++;
1085                 if ( nXHTMLIndex != -1 )
1086                     aIter++;
1087 				if ( nPDFIndex != -1 )
1088 					aIter++;
1089 				aImportantFilterGroup.insert( aIter, aExportFilter );
1090 				nFlashIndex = 0;
1091 			}
1092 			else
1093 				aFilterGroup.push_back( aExportFilter );
1094 		}
1095 
1096 		if ( xFilterGroupManager.is() )
1097 		{
1098 			// Add both html/pdf filter as a filter group to get a separator between both groups
1099 			if ( aImportantFilterGroup.size() > 0 )
1100 			{
1101 				Sequence< StringPair > aFilters( aImportantFilterGroup.size() );
1102 				for ( sal_Int32 i = 0; i < (sal_Int32)aImportantFilterGroup.size(); i++ )
1103 				{
1104 					aFilters[i].First	= addExtension( aImportantFilterGroup[i].aUIName,
1105 														aImportantFilterGroup[i].aWildcard,
1106 														sal_False, _rFileDlgImpl );
1107 					aFilters[i].Second	= aImportantFilterGroup[i].aWildcard;
1108 				}
1109 
1110 				try
1111 				{
1112 					xFilterGroupManager->appendFilterGroup( ::rtl::OUString(), aFilters );
1113 				}
1114 				catch( IllegalArgumentException )
1115 				{
1116 				}
1117 			}
1118 
1119 			if ( aFilterGroup.size() > 0 )
1120 			{
1121 				Sequence< StringPair > aFilters( aFilterGroup.size() );
1122 				for ( sal_Int32 i = 0; i < (sal_Int32)aFilterGroup.size(); i++ )
1123 				{
1124 					aFilters[i].First	= addExtension( aFilterGroup[i].aUIName,
1125 														aFilterGroup[i].aWildcard,
1126 														sal_False, _rFileDlgImpl );
1127 					aFilters[i].Second	= aFilterGroup[i].aWildcard;
1128 				}
1129 
1130 				try
1131 				{
1132 					xFilterGroupManager->appendFilterGroup( ::rtl::OUString(), aFilters );
1133 				}
1134 				catch( IllegalArgumentException )
1135 				{
1136 				}
1137 			}
1138 		}
1139 		else
1140 		{
1141 			// Fallback solution just add both filter groups as single filters
1142 			sal_Int32 n;
1143 
1144 			for ( n = 0; n < (sal_Int32)aImportantFilterGroup.size(); n++ )
1145 			{
1146 				try
1147 				{
1148 					rtl::OUString aUIName = addExtension( aImportantFilterGroup[n].aUIName,
1149 														  aImportantFilterGroup[n].aWildcard,
1150 														  sal_False, _rFileDlgImpl );
1151 					_rxFilterManager->appendFilter( aUIName, aImportantFilterGroup[n].aWildcard  );
1152 					if ( !_rFirstNonEmpty.getLength() )
1153 						_rFirstNonEmpty = sUIName;
1154 
1155 				}
1156 				catch( IllegalArgumentException )
1157 				{
1158 		#ifdef DBG_UTIL
1159 					ByteString aMsg( "Could not append Filter" );
1160 					aMsg += ByteString( String( sUIName ), osl_getThreadTextEncoding() );
1161 					DBG_ERRORFILE( aMsg.GetBuffer() );
1162 		#endif
1163 				}
1164 			}
1165 
1166 			for ( n = 0; n < (sal_Int32)aFilterGroup.size(); n++ )
1167 			{
1168 				try
1169 				{
1170 					rtl::OUString aUIName = addExtension( aFilterGroup[n].aUIName,
1171 														  aFilterGroup[n].aWildcard,
1172 														  sal_False, _rFileDlgImpl );
1173 					_rxFilterManager->appendFilter( aUIName, aFilterGroup[n].aWildcard );
1174 					if ( !_rFirstNonEmpty.getLength() )
1175 						_rFirstNonEmpty = sUIName;
1176 
1177 				}
1178 				catch( IllegalArgumentException )
1179 				{
1180 		#ifdef DBG_UTIL
1181 					ByteString aMsg( "Could not append Filter" );
1182 					aMsg += ByteString( String( sUIName ), osl_getThreadTextEncoding() );
1183 					DBG_ERRORFILE( aMsg.GetBuffer() );
1184 		#endif
1185 				}
1186 			}
1187 		}
1188 	}
1189 
1190 	//--------------------------------------------------------------------
appendFiltersForOpen(TSortedFilterList & _rFilterMatcher,const Reference<XFilterManager> & _rxFilterManager,::rtl::OUString & _rFirstNonEmpty,FileDialogHelper_Impl & _rFileDlgImpl)1191 	void appendFiltersForOpen( TSortedFilterList& _rFilterMatcher,
1192 							   const Reference< XFilterManager >& _rxFilterManager,
1193 							   ::rtl::OUString& _rFirstNonEmpty, FileDialogHelper_Impl& _rFileDlgImpl )
1194 	{
1195 		DBG_ASSERT( _rxFilterManager.is(), "sfx2::appendFiltersForOpen: invalid manager!" );
1196 		if ( !_rxFilterManager.is() )
1197 			return;
1198 
1199 #ifdef DISABLE_GROUPING_AND_CLASSIFYING
1200         // ===============================================================
1201 		// ensure that there's an entry "all" (with wildcard *.*)
1202 		lcl_EnsureAllFilesEntry( _rFilterMatcher, _rxFilterManager, _rFirstNonEmpty );
1203 
1204         // ===============================================================
1205 		appendFilters( _rFilterMatcher, _rxFilterManager, _rFirstNonEmpty );
1206 #else
1207 
1208         // ===============================================================
1209 		// group and classify the filters
1210 		GroupedFilterList aAllFilters;
1211 		lcl_GroupAndClassify( _rFilterMatcher, aAllFilters );
1212 
1213         // ===============================================================
1214 		// ensure that we have the one "all files" entry
1215 		lcl_EnsureAllFilesEntry( _rFilterMatcher, aAllFilters );
1216 
1217         // ===============================================================
1218 		// the first non-empty string - which we assume is the first overall entry
1219 		if ( !aAllFilters.empty() )
1220 		{
1221 			const FilterGroup& rFirstGroup = *aAllFilters.begin();	// should be the global classes
1222 			if ( !rFirstGroup.empty() )
1223 				_rFirstNonEmpty = rFirstGroup.begin()->First;
1224 			// append first group, without extension
1225 			AppendFilterGroup aGroup( _rxFilterManager, &_rFileDlgImpl );
1226 			aGroup.appendGroup( rFirstGroup, false );
1227 		}
1228 
1229         // ===============================================================
1230 		// append the filters to the manager
1231 		if ( !aAllFilters.empty() )
1232 		{
1233 			::std::list< FilterGroup >::iterator pIter = aAllFilters.begin();
1234 			++pIter;
1235 			::std::for_each(
1236 				pIter, // first filter group was handled separately, see above
1237 				aAllFilters.end(),
1238 				AppendFilterGroup( _rxFilterManager, &_rFileDlgImpl ) );
1239 		}
1240 #endif
1241 	}
1242 
addExtension(const::rtl::OUString & _rDisplayText,const::rtl::OUString & _rExtension,sal_Bool _bForOpen,FileDialogHelper_Impl & _rFileDlgImpl)1243 	::rtl::OUString addExtension( const ::rtl::OUString& _rDisplayText,
1244 								  const ::rtl::OUString& _rExtension,
1245 								  sal_Bool _bForOpen, FileDialogHelper_Impl& _rFileDlgImpl )
1246 	{
1247 		static ::rtl::OUString sAllFilter( RTL_CONSTASCII_USTRINGPARAM( "(*.*)" ) );
1248 		static ::rtl::OUString sOpenBracket( RTL_CONSTASCII_USTRINGPARAM( " (" ) );
1249 		static ::rtl::OUString sCloseBracket( RTL_CONSTASCII_USTRINGPARAM( ")" ) );
1250 		::rtl::OUString sRet = _rDisplayText;
1251 
1252 		if ( sRet.indexOf( sAllFilter ) == -1 )
1253 		{
1254 			String sExt = _rExtension;
1255 			if ( !_bForOpen )
1256 				// show '*' in extensions only when opening a document
1257 				sExt.EraseAllChars( '*' );
1258 			sRet += sOpenBracket;
1259 			sRet += sExt;
1260 			sRet += sCloseBracket;
1261 		}
1262 		_rFileDlgImpl.addFilterPair( _rDisplayText, sRet );
1263 		return sRet;
1264 	}
1265 
1266 //........................................................................
1267 }	// namespace sfx2
1268 //........................................................................
1269 
1270 
1271